Index: /trunk/sources/HeuristicLab 3.3.sln
===================================================================
--- /trunk/sources/HeuristicLab 3.3.sln	(revision 13483)
+++ /trunk/sources/HeuristicLab 3.3.sln	(revision 13484)
@@ -2,5 +2,5 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 2013
-VisualStudioVersion = 12.0.31101.0
+VisualStudioVersion = 12.0.40629.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{96396439-A764-4022-A8D2-BE021449B8D1}"
@@ -24,4 +24,5 @@
 		{25087811-F74C-4128-BC86-8324271DA13E} = {25087811-F74C-4128-BC86-8324271DA13E}
 		{5AC82412-911B-4FA2-A013-EDC5E3F3FCC2} = {5AC82412-911B-4FA2-A013-EDC5E3F3FCC2}
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B} = {90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}
 		{662B4B15-8F4D-4AE5-B3EB-D91C215F5AF2} = {662B4B15-8F4D-4AE5-B3EB-D91C215F5AF2}
 		{E2419315-B10A-4BC1-B517-A24DCF4C59AC} = {E2419315-B10A-4BC1-B517-A24DCF4C59AC}
@@ -74,4 +75,5 @@
 		{E10F395F-C8A6-48AD-B470-9AA7A1F43809} = {E10F395F-C8A6-48AD-B470-9AA7A1F43809}
 		{0C378762-D5DB-488A-8931-2BA42B1B7CBF} = {0C378762-D5DB-488A-8931-2BA42B1B7CBF}
+		{97198965-AFEA-496B-B3B1-316905C43FD6} = {97198965-AFEA-496B-B3B1-316905C43FD6}
 		{3B90F866-70F8-43EF-A541-51819D255B7B} = {3B90F866-70F8-43EF-A541-51819D255B7B}
 		{07486E68-1517-4B9D-A58D-A38E99AE71AB} = {07486E68-1517-4B9D-A58D-A38E99AE71AB}
@@ -449,4 +451,8 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.ALPS-3.3", "HeuristicLab.Algorithms.ALPS\3.3\HeuristicLab.Algorithms.ALPS-3.3.csproj", "{59F354CB-FE13-4253-AED2-AD86372BEC27}"
+EndProject
+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
@@ -2188,4 +2194,28 @@
 		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Release|x86.ActiveCfg = Release|x86
 		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Release|x86.Build.0 = Release|x86
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Debug|x64.ActiveCfg = Debug|x64
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Debug|x64.Build.0 = Debug|x64
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Debug|x86.ActiveCfg = Debug|x86
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Debug|x86.Build.0 = Debug|x86
+		{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
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Release|x64.ActiveCfg = Release|x64
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Release|x64.Build.0 = Release|x64
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Release|x86.ActiveCfg = Release|x86
+		{97198965-AFEA-496B-B3B1-316905C43FD6}.Release|x86.Build.0 = Release|x86
+		{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}.Debug|x64.ActiveCfg = Debug|x64
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Debug|x64.Build.0 = Debug|x64
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Debug|x86.ActiveCfg = Debug|x86
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Debug|x86.Build.0 = Debug|x86
+		{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
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Release|x64.ActiveCfg = Release|x64
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Release|x64.Build.0 = Release|x64
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Release|x86.ActiveCfg = Release|x86
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/HeuristicLab.Problems.Instances.TSPLIB-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/HeuristicLab.Problems.Instances.TSPLIB-3.3.csproj	(revision 13483)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/HeuristicLab.Problems.Instances.TSPLIB-3.3.csproj	(revision 13484)
@@ -115,8 +115,13 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="TSPLIBHeterogeneousPTSPDataDescriptor.cs" />
+    <Compile Include="TSPLIBHomogeneousPTSPDataDescriptor.cs" />
+    <Compile Include="TSPLIBHeterogeneousPTSPInstanceProvider.cs" />
+    <Compile Include="TSPLIBPTSPInstanceProvider.cs" />
     <Compile Include="TSPLIBInstanceProvider.cs" />
     <Compile Include="TSPLIBATSPInstanceProvider.cs" />
     <Compile Include="TSPLIBCVRPInstanceProvider.cs" />
     <Compile Include="TSPLIBDataDescriptor.cs" />
+    <Compile Include="TSPLIBHomogeneousPTSPInstanceProvider.cs" />
     <Compile Include="TSPLIBTSPInstanceProvider.cs" />
     <Compile Include="TSPLIBParser.cs" />
@@ -150,5 +155,4 @@
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBATSPInstanceProvider.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBATSPInstanceProvider.cs	(revision 13483)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBATSPInstanceProvider.cs	(revision 13484)
@@ -36,5 +36,5 @@
     protected override string FileExtension { get { return "atsp"; } }
 
-    protected override ATSPData LoadInstance(TSPLIBParser parser) {
+    protected override ATSPData LoadInstance(TSPLIBParser parser, IDataDescriptor descriptor = null) {
       var instance = new ATSPData();
 
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBCVRPInstanceProvider.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBCVRPInstanceProvider.cs	(revision 13483)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBCVRPInstanceProvider.cs	(revision 13484)
@@ -36,5 +36,5 @@
     protected override string FileExtension { get { return "vrp"; } }
 
-    protected override CVRPData LoadInstance(TSPLIBParser parser) {
+    protected override CVRPData LoadInstance(TSPLIBParser parser, IDataDescriptor descriptor = null) {
       parser.Parse();
       var instance = new CVRPData();
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHeterogeneousPTSPDataDescriptor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHeterogeneousPTSPDataDescriptor.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHeterogeneousPTSPDataDescriptor.cs	(revision 13484)
@@ -0,0 +1,36 @@
+﻿#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
+
+
+namespace HeuristicLab.Problems.Instances.TSPLIB {
+  internal class TSPLIBHeterogeneousPTSPDataDescriptor : TSPLIBDataDescriptor {
+    public int Seed { get; internal set; }
+
+    internal TSPLIBHeterogeneousPTSPDataDescriptor(string name, string description, string instanceIdentifier, string solutionIdentifier, int seed)
+      : base(name, description, instanceIdentifier, solutionIdentifier) {
+      this.Name = name;
+      this.Description = description;
+      this.InstanceIdentifier = instanceIdentifier;
+      this.SolutionIdentifier = solutionIdentifier;
+      this.Seed = seed;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHeterogeneousPTSPInstanceProvider.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHeterogeneousPTSPInstanceProvider.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHeterogeneousPTSPInstanceProvider.cs	(revision 13484)
@@ -0,0 +1,103 @@
+﻿#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.Collections.Generic;
+using System.Linq;
+
+namespace HeuristicLab.Problems.Instances.TSPLIB {
+  public class TSPLIBHeterogeneousPTSPInstanceProvider : TSPLIBPTSPInstanceProvider {
+
+    public override string Name {
+      get { return "TSPLIB (heterogeneous symmetric PTSP)"; }
+    }
+
+    public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
+      foreach (var desc in base.GetDataDescriptors().OfType<TSPLIBDataDescriptor>()) {
+        desc.SolutionIdentifier = null;
+        yield return desc;
+      }
+    }
+
+    protected override double[] GetProbabilities(IDataDescriptor descriptor, PTSPData instance) {
+      var random = new MarsagliaRandom(GetInstanceHash(instance.Name));
+      return Enumerable.Range(0, instance.Dimension).Select(_ => (int)Math.Round((0.1 + 0.9 * random.NextDouble()) * 100) / 100.0).ToArray();
+    }
+
+    // Bernstein's hash function
+    private uint GetInstanceHash(string name) {
+      uint hash = 5381;
+      var len = name.Length;
+      for (var i = 0; i < len; i++)
+        unchecked { hash = ((hash * 33) + name[i]); }
+      return hash;
+    }
+
+    /// <summary>
+    /// This class is used to randomly generate PTSP instances given the TSPLIB instances.
+    /// An own implementation of a RNG was used in order to avoid possible implementation changes
+    /// in future .NET versions which would result in entirely different instances.
+    /// </summary>
+    /// <remarks>
+    /// RNG is implemented according to George Marsaglia https://en.wikipedia.org/wiki/Multiply-with-carry
+    /// </remarks>
+    private class MarsagliaRandom {
+      /*
+       * S = 2111111111*X[n-4] + 1492*X[n-3] + 1776*X[n-2] + 5115*X[n-1] + C
+       * X[n] = S modulo 2^32
+       * C = floor(S / 2^32)
+       * 
+       */
+      private readonly uint[] mem = new uint[4];
+      private uint c;
+
+      public MarsagliaRandom(uint s) {
+        int i;
+        for (i = 0; i < mem.Length; i++) {
+          unchecked { s = s * 31294061 + 1; }
+          mem[i] = s;
+        }
+        unchecked { c = s * 31294061 + 1; }
+      }
+
+      private uint Next() {
+        unchecked {
+          ulong wsum = 2111111111 * mem[0]
+                      + 1492 * mem[1]
+                      + 1776 * mem[2]
+                      + 5115 * mem[3]
+                      + c;
+
+          mem[0] = mem[1];
+          mem[1] = mem[2];
+          mem[2] = mem[3];
+          mem[3] = (uint)wsum;
+          c = (uint)(wsum >> 32);
+          return mem[3];
+        }
+      }
+
+      public double NextDouble() {
+        return (double)Next() / uint.MaxValue;
+      }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHomogeneousPTSPDataDescriptor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHomogeneousPTSPDataDescriptor.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHomogeneousPTSPDataDescriptor.cs	(revision 13484)
@@ -0,0 +1,35 @@
+﻿#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
+
+namespace HeuristicLab.Problems.Instances.TSPLIB {
+  internal class TSPLIBHomogeneousPTSPDataDescriptor : TSPLIBDataDescriptor {
+    public double Probability { get; internal set; }
+
+    internal TSPLIBHomogeneousPTSPDataDescriptor(string name, string description, string instanceIdentifier, string solutionIdentifier, double probability)
+      : base(name, description, instanceIdentifier, solutionIdentifier) {
+      this.Name = name;
+      this.Description = description;
+      this.InstanceIdentifier = instanceIdentifier;
+      this.SolutionIdentifier = solutionIdentifier;
+      this.Probability = probability;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHomogeneousPTSPInstanceProvider.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHomogeneousPTSPInstanceProvider.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBHomogeneousPTSPInstanceProvider.cs	(revision 13484)
@@ -0,0 +1,54 @@
+﻿#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.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace HeuristicLab.Problems.Instances.TSPLIB {
+  public class TSPLIBHomogeneousPTSPInstanceProvider : TSPLIBPTSPInstanceProvider {
+    private static readonly double[] Probabilities = new[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 };
+
+    public override string Name {
+      get { return "TSPLIB (homogeneous symmetric PTSP)"; }
+    }
+
+    public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
+      var tspDescriptors = base.GetDataDescriptors().OfType<TSPLIBDataDescriptor>();
+      foreach (var desc in tspDescriptors) {
+        foreach (var p in Probabilities) {
+          yield return new TSPLIBHomogeneousPTSPDataDescriptor(
+            desc.Name + "-" + p.ToString(CultureInfo.InvariantCulture.NumberFormat),
+            desc.Description,
+            desc.InstanceIdentifier,
+            p == 1.0 ? desc.SolutionIdentifier : null,
+            p);
+        }
+      }
+    }
+
+    protected override double[] GetProbabilities(IDataDescriptor descriptor, PTSPData instance) {
+      var ptspDesc = descriptor as TSPLIBHomogeneousPTSPDataDescriptor;
+      return ptspDesc != null ? Enumerable.Range(0, instance.Dimension).Select(_ => ptspDesc.Probability).ToArray()
+                              : Enumerable.Range(0, instance.Dimension).Select(_ => 0.5).ToArray();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBInstanceProvider.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBInstanceProvider.cs	(revision 13483)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBInstanceProvider.cs	(revision 13484)
@@ -45,5 +45,5 @@
     protected abstract string FileExtension { get; }
 
-    protected abstract T LoadInstance(TSPLIBParser parser);
+    protected abstract T LoadInstance(TSPLIBParser parser, IDataDescriptor descriptor = null);
     protected abstract void LoadSolution(TSPLIBParser parser, T instance);
 
@@ -74,5 +74,5 @@
         var stream = entry.Open();
         var parser = new TSPLIBParser(stream);
-        var instance = LoadInstance(parser);
+        var instance = LoadInstance(parser, id);
 
         if (!String.IsNullOrEmpty(descriptor.SolutionIdentifier)) {
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBPTSPInstanceProvider.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBPTSPInstanceProvider.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBPTSPInstanceProvider.cs	(revision 13484)
@@ -0,0 +1,95 @@
+﻿#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.IO;
+using System.Linq;
+
+namespace HeuristicLab.Problems.Instances.TSPLIB {
+  public abstract class TSPLIBPTSPInstanceProvider : TSPLIBInstanceProvider<PTSPData> {
+
+    public override string Description {
+      get { return "Traveling Salesman Problem Library (adapted for generating PTSP instances)"; }
+    }
+
+    protected override string FileExtension { get { return "tsp"; } }
+
+    protected override PTSPData LoadInstance(TSPLIBParser parser, IDataDescriptor descriptor = null) {
+      parser.Parse();
+      if (parser.FixedEdges != null) throw new InvalidDataException("TSP instance " + parser.Name + " contains fixed edges which are not supported by HeuristicLab.");
+      var instance = new PTSPData();
+      instance.Dimension = parser.Dimension;
+      instance.Coordinates = parser.Vertices != null ? parser.Vertices : parser.DisplayVertices;
+      instance.Distances = parser.Distances;
+      switch (parser.EdgeWeightType) {
+        case TSPLIBEdgeWeightTypes.ATT:
+          instance.DistanceMeasure = DistanceMeasure.Att; break;
+        case TSPLIBEdgeWeightTypes.CEIL_2D:
+          instance.DistanceMeasure = DistanceMeasure.UpperEuclidean; break;
+        case TSPLIBEdgeWeightTypes.EUC_2D:
+          instance.DistanceMeasure = DistanceMeasure.RoundedEuclidean; break;
+        case TSPLIBEdgeWeightTypes.EUC_3D:
+          throw new InvalidDataException("3D coordinates are not supported.");
+        case TSPLIBEdgeWeightTypes.EXPLICIT:
+          instance.DistanceMeasure = DistanceMeasure.Direct; break;
+        case TSPLIBEdgeWeightTypes.GEO:
+          instance.DistanceMeasure = DistanceMeasure.Geo; break;
+        case TSPLIBEdgeWeightTypes.MAN_2D:
+          instance.DistanceMeasure = DistanceMeasure.Manhattan; break;
+        case TSPLIBEdgeWeightTypes.MAN_3D:
+          throw new InvalidDataException("3D coordinates are not supported.");
+        case TSPLIBEdgeWeightTypes.MAX_2D:
+          instance.DistanceMeasure = DistanceMeasure.Maximum; break;
+        case TSPLIBEdgeWeightTypes.MAX_3D:
+          throw new InvalidDataException("3D coordinates are not supported.");
+        default:
+          throw new InvalidDataException("The given edge weight is not supported by HeuristicLab.");
+      }
+
+      instance.Name = parser.Name;
+      instance.Description = parser.Comment
+        + Environment.NewLine + Environment.NewLine
+        + GetInstanceDescription();
+
+      instance.Probabilities = GetProbabilities(descriptor, instance);
+      return instance;
+    }
+
+    protected abstract double[] GetProbabilities(IDataDescriptor descriptor, PTSPData instance);
+
+    protected override void LoadSolution(TSPLIBParser parser, PTSPData instance) {
+      parser.Parse();
+      instance.BestKnownTour = parser.Tour.FirstOrDefault();
+    }
+
+    public PTSPData LoadData(string tspFile, string tourFile, double? bestQuality) {
+      var data = LoadInstance(new TSPLIBParser(tspFile));
+      if (!String.IsNullOrEmpty(tourFile)) {
+        var tourParser = new TSPLIBParser(tourFile);
+        LoadSolution(tourParser, data);
+      }
+      if (bestQuality.HasValue)
+        data.BestKnownQuality = bestQuality.Value;
+      return data;
+    }
+
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBTSPInstanceProvider.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBTSPInstanceProvider.cs	(revision 13483)
+++ /trunk/sources/HeuristicLab.Problems.Instances.TSPLIB/3.3/TSPLIBTSPInstanceProvider.cs	(revision 13484)
@@ -37,5 +37,5 @@
     protected override string FileExtension { get { return "tsp"; } }
 
-    protected override TSPData LoadInstance(TSPLIBParser parser) {
+    protected override TSPData LoadInstance(TSPLIBParser parser, IDataDescriptor descriptor = null) {
       parser.Parse();
       if (parser.FixedEdges != null) throw new InvalidDataException("TSP instance " + parser.Name + " contains fixed edges which are not supported by HeuristicLab.");
Index: /trunk/sources/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj	(revision 13483)
+++ /trunk/sources/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj	(revision 13484)
@@ -121,4 +121,5 @@
     <Compile Include="ProblemInstanceManager.cs" />
     <Compile Include="IProblemInstanceExporter.cs" />
+    <Compile Include="Types\PTSPData.cs" />
     <Compile Include="Types\ATSPData.cs" />
     <Compile Include="Types\JSSPData.cs" />
Index: /trunk/sources/HeuristicLab.Problems.Instances/3.3/Types/DistanceHelper.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances/3.3/Types/DistanceHelper.cs	(revision 13483)
+++ /trunk/sources/HeuristicLab.Problems.Instances/3.3/Types/DistanceHelper.cs	(revision 13484)
@@ -21,11 +21,8 @@
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace HeuristicLab.Problems.Instances {
   public enum DistanceMeasure { Direct, Euclidean, RoundedEuclidean, UpperEuclidean, Geo, Manhattan, Maximum, Att };
-  
+
   public static class DistanceHelper {
     /// <summary>
@@ -35,5 +32,5 @@
     public static double[,] GetDistanceMatrix(DistanceMeasure distanceMeasure, double[,] coordinates, double[,] distances, int dimension) {
       if (distances != null) return distances;
-      
+
       distances = new double[dimension, dimension];
       for (int i = 0; i < dimension - 1; i++)
@@ -44,4 +41,27 @@
 
       return distances;
+    }
+
+    public static double GetDistance(DistanceMeasure distanceMeasure, double x1, double y1, double x2, double y2) {
+      switch (distanceMeasure) {
+        case DistanceMeasure.Att:
+          return AttDistance(x1, y1, x2, y2);
+        case DistanceMeasure.Direct:
+          throw new ArgumentException("Direct distance measure requires distance matrix for distance calculation.");
+        case DistanceMeasure.Euclidean:
+          return EuclideanDistance(x1, y1, x2, y2);
+        case DistanceMeasure.Geo:
+          return GeoDistance(x1, y1, x2, y2);
+        case DistanceMeasure.Manhattan:
+          return ManhattanDistance(x1, y1, x2, y2);
+        case DistanceMeasure.Maximum:
+          return MaximumDistance(x1, y1, x2, y2);
+        case DistanceMeasure.RoundedEuclidean:
+          return Math.Round(EuclideanDistance(x1, y1, x2, y2));
+        case DistanceMeasure.UpperEuclidean:
+          return Math.Ceiling(EuclideanDistance(x1, y1, x2, y2));
+        default:
+          throw new InvalidOperationException("Distance measure is not known.");
+      }
     }
 
Index: /trunk/sources/HeuristicLab.Problems.Instances/3.3/Types/PTSPData.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Instances/3.3/Types/PTSPData.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.Instances/3.3/Types/PTSPData.cs	(revision 13484)
@@ -0,0 +1,12 @@
+﻿
+namespace HeuristicLab.Problems.Instances {
+  /// <summary>
+  /// Describes instances of the Probabilistic Traveling Salesman Problem (PTSP).
+  /// </summary>
+  public class PTSPData : TSPData {
+    /// <summary>
+    /// The probabilities for each of the cities to appear in a route.
+    /// </summary>
+    public double[] Probabilities { get; set; }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/HeuristicLab.Problems.PTSP.Views-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/HeuristicLab.Problems.PTSP.Views-3.3.csproj	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/HeuristicLab.Problems.PTSP.Views-3.3.csproj	(revision 13484)
@@ -0,0 +1,200 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.PTSP.Views</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.PTSP.Views-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core.Views\3.3\HeuristicLab.Core.Views-3.3.csproj">
+      <Project>{E226881D-315F-423D-B419-A766FE0D8685}</Project>
+      <Name>HeuristicLab.Core.Views-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.PermutationEncoding\3.3\HeuristicLab.Encodings.PermutationEncoding-3.3.csproj">
+      <Project>{DBECB8B0-B166-4133-BAF1-ED67C3FD7FCA}</Project>
+      <Name>HeuristicLab.Encodings.PermutationEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.MainForm.WindowsForms\3.3\HeuristicLab.MainForm.WindowsForms-3.3.csproj">
+      <Project>{AB687BBE-1BFE-476B-906D-44237135431D}</Project>
+      <Name>HeuristicLab.MainForm.WindowsForms-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.MainForm\3.3\HeuristicLab.MainForm-3.3.csproj">
+      <Project>{3BD61258-31DA-4B09-89C0-4F71FEF5F05A}</Project>
+      <Name>HeuristicLab.MainForm-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization.Views\3.3\HeuristicLab.Optimization.Views-3.3.csproj">
+      <Project>{662B4B15-8F4D-4AE5-B3EB-D91C215F5AF2}</Project>
+      <Name>HeuristicLab.Optimization.Views-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>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.Instances\3.3\HeuristicLab.Problems.Instances-3.3.csproj">
+      <Project>{3540E29E-4793-49E7-8EE2-FEA7F61C3994}</Project>
+      <Name>HeuristicLab.Problems.Instances-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.PTSP\3.3\HeuristicLab.Problems.PTSP-3.3.csproj">
+      <Project>{97198965-afea-496b-b3b1-316905c43fd6}</Project>
+      <Name>HeuristicLab.Problems.PTSP-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
+      <Project>{F4539FB6-4708-40C9-BE64-0A1390AEA197}</Project>
+      <Name>HeuristicLab.Random-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="PathPTSPTourView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="PathPTSPTourView.Designer.cs">
+      <DependentUpon>PathPTSPTourView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ProbabilisticTravelingSalesmanProblemView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="ProbabilisticTravelingSalesmanProblemView.Designer.cs">
+      <DependentUpon>ProbabilisticTravelingSalesmanProblemView.cs</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set OutDir=$(OutDir)
+set TargetDir=$(TargetDir)
+
+call PreBuildEvent.cmd
+    </PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
+    </PreBuildEvent>
+  </PropertyGroup>
+  <!-- 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>
+  -->
+</Project>
Index: /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/PathPTSPTourView.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/PathPTSPTourView.Designer.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/PathPTSPTourView.Designer.cs	(revision 13484)
@@ -0,0 +1,220 @@
+#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
+
+namespace HeuristicLab.Problems.PTSP.Views {
+  partial class PathPTSPTourView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing) {
+        if (components != null) components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.pictureBox = new System.Windows.Forms.PictureBox();
+      this.tabControl = new HeuristicLab.MainForm.WindowsForms.DragOverTabControl();
+      this.visualizationTabPage = new System.Windows.Forms.TabPage();
+      this.valueTabPage = new System.Windows.Forms.TabPage();
+      this.tourGroupBox = new System.Windows.Forms.GroupBox();
+      this.tourViewHost = new HeuristicLab.MainForm.WindowsForms.ViewHost();
+      this.splitContainer = new System.Windows.Forms.SplitContainer();
+      this.qualityGroupBox = new System.Windows.Forms.GroupBox();
+      this.qualityViewHost = new HeuristicLab.MainForm.WindowsForms.ViewHost();
+      ((System.ComponentModel.ISupportInitialize)(this.pictureBox)).BeginInit();
+      this.tabControl.SuspendLayout();
+      this.visualizationTabPage.SuspendLayout();
+      this.valueTabPage.SuspendLayout();
+      this.tourGroupBox.SuspendLayout();
+      this.splitContainer.Panel1.SuspendLayout();
+      this.splitContainer.Panel2.SuspendLayout();
+      this.splitContainer.SuspendLayout();
+      this.qualityGroupBox.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // pictureBox
+      // 
+      this.pictureBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.pictureBox.BackColor = System.Drawing.Color.White;
+      this.pictureBox.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
+      this.pictureBox.Location = new System.Drawing.Point(6, 6);
+      this.pictureBox.Name = "pictureBox";
+      this.pictureBox.Size = new System.Drawing.Size(403, 288);
+      this.pictureBox.TabIndex = 0;
+      this.pictureBox.TabStop = false;
+      this.pictureBox.SizeChanged += new System.EventHandler(this.pictureBox_SizeChanged);
+      // 
+      // tabControl
+      // 
+      this.tabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.tabControl.Controls.Add(this.visualizationTabPage);
+      this.tabControl.Controls.Add(this.valueTabPage);
+      this.tabControl.Location = new System.Drawing.Point(0, 3);
+      this.tabControl.Name = "tabControl";
+      this.tabControl.SelectedIndex = 0;
+      this.tabControl.Size = new System.Drawing.Size(423, 326);
+      this.tabControl.TabIndex = 0;
+      // 
+      // visualizationTabPage
+      // 
+      this.visualizationTabPage.Controls.Add(this.pictureBox);
+      this.visualizationTabPage.Location = new System.Drawing.Point(4, 22);
+      this.visualizationTabPage.Name = "visualizationTabPage";
+      this.visualizationTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.visualizationTabPage.Size = new System.Drawing.Size(415, 300);
+      this.visualizationTabPage.TabIndex = 0;
+      this.visualizationTabPage.Text = "Visualization";
+      this.visualizationTabPage.UseVisualStyleBackColor = true;
+      // 
+      // valueTabPage
+      // 
+      this.valueTabPage.Controls.Add(this.tourGroupBox);
+      this.valueTabPage.Location = new System.Drawing.Point(4, 22);
+      this.valueTabPage.Name = "valueTabPage";
+      this.valueTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.valueTabPage.Size = new System.Drawing.Size(415, 300);
+      this.valueTabPage.TabIndex = 1;
+      this.valueTabPage.Text = "Value";
+      this.valueTabPage.UseVisualStyleBackColor = true;
+      // 
+      // tourGroupBox
+      // 
+      this.tourGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.tourGroupBox.Controls.Add(this.tourViewHost);
+      this.tourGroupBox.Location = new System.Drawing.Point(6, 6);
+      this.tourGroupBox.Name = "tourGroupBox";
+      this.tourGroupBox.Size = new System.Drawing.Size(403, 288);
+      this.tourGroupBox.TabIndex = 0;
+      this.tourGroupBox.TabStop = false;
+      this.tourGroupBox.Text = "Tour";
+      // 
+      // tourViewHost
+      // 
+      this.tourViewHost.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.tourViewHost.Content = null;
+      this.tourViewHost.Location = new System.Drawing.Point(6, 19);
+      this.tourViewHost.Name = "tourViewHost";
+      this.tourViewHost.ReadOnly = false;
+      this.tourViewHost.Size = new System.Drawing.Size(391, 263);
+      this.tourViewHost.TabIndex = 0;
+      this.tourViewHost.ViewType = null;
+      // 
+      // splitContainer
+      // 
+      this.splitContainer.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.splitContainer.Location = new System.Drawing.Point(0, 0);
+      this.splitContainer.Name = "splitContainer";
+      this.splitContainer.Orientation = System.Windows.Forms.Orientation.Horizontal;
+      // 
+      // splitContainer.Panel1
+      // 
+      this.splitContainer.Panel1.Controls.Add(this.qualityGroupBox);
+      // 
+      // splitContainer.Panel2
+      // 
+      this.splitContainer.Panel2.Controls.Add(this.tabControl);
+      this.splitContainer.Size = new System.Drawing.Size(423, 402);
+      this.splitContainer.SplitterDistance = 69;
+      this.splitContainer.TabIndex = 0;
+      // 
+      // qualityGroupBox
+      // 
+      this.qualityGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.qualityGroupBox.Controls.Add(this.qualityViewHost);
+      this.qualityGroupBox.Location = new System.Drawing.Point(0, 0);
+      this.qualityGroupBox.Name = "qualityGroupBox";
+      this.qualityGroupBox.Size = new System.Drawing.Size(423, 66);
+      this.qualityGroupBox.TabIndex = 0;
+      this.qualityGroupBox.TabStop = false;
+      this.qualityGroupBox.Text = "Quality";
+      // 
+      // qualityViewHost
+      // 
+      this.qualityViewHost.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.qualityViewHost.Content = null;
+      this.qualityViewHost.Location = new System.Drawing.Point(6, 19);
+      this.qualityViewHost.Name = "qualityViewHost";
+      this.qualityViewHost.ReadOnly = false;
+      this.qualityViewHost.Size = new System.Drawing.Size(411, 41);
+      this.qualityViewHost.TabIndex = 0;
+      this.qualityViewHost.ViewType = null;
+      // 
+      // PathTSPTourView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+      this.Controls.Add(this.splitContainer);
+      this.Name = "PathTSPTourView";
+      this.Size = new System.Drawing.Size(423, 402);
+      ((System.ComponentModel.ISupportInitialize)(this.pictureBox)).EndInit();
+      this.tabControl.ResumeLayout(false);
+      this.visualizationTabPage.ResumeLayout(false);
+      this.valueTabPage.ResumeLayout(false);
+      this.tourGroupBox.ResumeLayout(false);
+      this.splitContainer.Panel1.ResumeLayout(false);
+      this.splitContainer.Panel2.ResumeLayout(false);
+      this.splitContainer.ResumeLayout(false);
+      this.qualityGroupBox.ResumeLayout(false);
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.PictureBox pictureBox;
+    private HeuristicLab.MainForm.WindowsForms.DragOverTabControl tabControl;
+    private System.Windows.Forms.TabPage visualizationTabPage;
+    private System.Windows.Forms.TabPage valueTabPage;
+    private System.Windows.Forms.GroupBox tourGroupBox;
+    private HeuristicLab.MainForm.WindowsForms.ViewHost tourViewHost;
+    private System.Windows.Forms.SplitContainer splitContainer;
+    private System.Windows.Forms.GroupBox qualityGroupBox;
+    private HeuristicLab.MainForm.WindowsForms.ViewHost qualityViewHost;
+
+
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/PathPTSPTourView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/PathPTSPTourView.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/PathPTSPTourView.cs	(revision 13484)
@@ -0,0 +1,169 @@
+#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.Core.Views;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.MainForm;
+
+namespace HeuristicLab.Problems.PTSP.Views {
+  /// <summary>
+  /// The base class for visual representations of a path tour for a PTSP.
+  /// </summary>
+  [View("PathPTSPTour View")]
+  [Content(typeof(PathPTSPTour), true)]
+  public sealed partial class PathPTSPTourView : ItemView {
+    public new PathPTSPTour Content {
+      get { return (PathPTSPTour)base.Content; }
+      set { base.Content = value; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="PathPTSPTourView"/>.
+    /// </summary>
+    public PathPTSPTourView() {
+      InitializeComponent();
+    }
+
+    protected override void DeregisterContentEvents() {
+      Content.QualityChanged -= new EventHandler(Content_QualityChanged);
+      Content.CoordinatesChanged -= new EventHandler(Content_CoordinatesChanged);
+      Content.PermutationChanged -= new EventHandler(Content_PermutationChanged);
+      Content.ProbabilitiesChanged -= new EventHandler(Content_ProbabilitiesChanged);
+      base.DeregisterContentEvents();
+    }
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.QualityChanged += new EventHandler(Content_QualityChanged);
+      Content.CoordinatesChanged += new EventHandler(Content_CoordinatesChanged);
+      Content.PermutationChanged += new EventHandler(Content_PermutationChanged);
+      Content.ProbabilitiesChanged += new EventHandler(Content_ProbabilitiesChanged);
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+        qualityViewHost.Content = null;
+        pictureBox.Image = null;
+        tourViewHost.Content = null;
+      } else {
+        qualityViewHost.Content = Content.Quality;
+        GenerateImage();
+        tourViewHost.Content = Content.Permutation;
+      }
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      qualityGroupBox.Enabled = Content != null;
+      pictureBox.Enabled = Content != null;
+      tourGroupBox.Enabled = Content != null;
+    }
+
+    private void GenerateImage() {
+      if ((pictureBox.Width > 0) && (pictureBox.Height > 0)) {
+        if (Content == null) {
+          pictureBox.Image = null;
+        } else {
+          DoubleMatrix coordinates = Content.Coordinates;
+          Permutation permutation = Content.Permutation;
+          DoubleArray probabilities = Content.Probabilities;
+          Bitmap bitmap = new Bitmap(pictureBox.Width, pictureBox.Height);
+
+          if ((coordinates != null) && (coordinates.Rows > 0) && (coordinates.Columns == 2) && (probabilities.Length == coordinates.Rows)) {
+            double xMin = double.MaxValue, yMin = double.MaxValue, xMax = double.MinValue, yMax = double.MinValue;
+            for (int i = 0; i < coordinates.Rows; i++) {
+              if (xMin > coordinates[i, 0]) xMin = coordinates[i, 0];
+              if (yMin > coordinates[i, 1]) yMin = coordinates[i, 1];
+              if (xMax < coordinates[i, 0]) xMax = coordinates[i, 0];
+              if (yMax < coordinates[i, 1]) yMax = coordinates[i, 1];
+            }
+
+            int border = 20;
+            double xStep = xMax != xMin ? (pictureBox.Width - 2 * border) / (xMax - xMin) : 1;
+            double yStep = yMax != yMin ? (pictureBox.Height - 2 * border) / (yMax - yMin) : 1;
+
+            Point[] points = new Point[coordinates.Rows];
+            for (int i = 0; i < coordinates.Rows; i++)
+              points[i] = new Point(border + ((int)((coordinates[i, 0] - xMin) * xStep)),
+                                    bitmap.Height - (border + ((int)((coordinates[i, 1] - yMin) * yStep))));
+
+            using (Graphics graphics = Graphics.FromImage(bitmap)) {
+              if (permutation != null && permutation.Length > 1) {
+                Point[] tour = new Point[permutation.Length];
+                for (int i = 0; i < permutation.Length; i++) {
+                  if (permutation[i] >= 0 && permutation[i] < points.Length)
+                    tour[i] = points[permutation[i]];
+                }
+                graphics.DrawPolygon(Pens.Black, tour);
+              }
+              for (int i = 0; i < points.Length; i++)
+                graphics.FillRectangle(Brushes.Red, points[i].X - 2, points[i].Y - 2, Convert.ToInt32(probabilities[i] * 20), Convert.ToInt32(probabilities[i] * 20));
+            }
+          } else {
+            using (Graphics graphics = Graphics.FromImage(bitmap)) {
+              graphics.Clear(Color.White);
+              Font font = new Font(FontFamily.GenericSansSerif, 12, FontStyle.Regular);
+              string text = "No coordinates defined or in wrong format.";
+              SizeF strSize = graphics.MeasureString(text, font);
+              graphics.DrawString(text, font, Brushes.Black, (float)(pictureBox.Width - strSize.Width) / 2.0f, (float)(pictureBox.Height - strSize.Height) / 2.0f);
+            }
+          }
+          pictureBox.Image = bitmap;
+        }
+      }
+    }
+
+    private void Content_QualityChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_QualityChanged), sender, e);
+      else
+        qualityViewHost.Content = Content.Quality;
+    }
+    private void Content_CoordinatesChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_CoordinatesChanged), sender, e);
+      else
+        GenerateImage();
+    }
+    private void Content_PermutationChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_PermutationChanged), sender, e);
+      else {
+        GenerateImage();
+        tourViewHost.Content = Content.Permutation;
+      }
+    }
+    private void Content_ProbabilitiesChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_ProbabilitiesChanged), sender, e);
+      else {
+        GenerateImage();
+      }
+    }
+
+    private void pictureBox_SizeChanged(object sender, EventArgs e) {
+      GenerateImage();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/Plugin.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/Plugin.cs.frame	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/Plugin.cs.frame	(revision 13484)
@@ -0,0 +1,41 @@
+﻿#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 HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.PTSP.Views {
+  [Plugin("HeuristicLab.Problems.PTSP.Views", "3.3.13.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.PTSP.Views-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Core.Views", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.PermutationEncoding", "3.3")]
+  [PluginDependency("HeuristicLab.MainForm", "3.3")]
+  [PluginDependency("HeuristicLab.MainForm.WindowsForms", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Views", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.PTSP", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  public class HeuristicLabProblemsPTSPViewsPlugin : PluginBase {
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/ProbabilisticTravelingSalesmanProblemView.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/ProbabilisticTravelingSalesmanProblemView.Designer.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/ProbabilisticTravelingSalesmanProblemView.Designer.cs	(revision 13484)
@@ -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
+
+namespace HeuristicLab.Problems.PTSP.Views {
+  partial class ProbabilisticTravelingSalesmanProblemView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    protected override void Dispose(bool disposing) {
+      if (disposing) {
+        if (components != null) components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.tabControl = new HeuristicLab.MainForm.WindowsForms.DragOverTabControl();
+      this.parametersTabPage = new System.Windows.Forms.TabPage();
+      this.visualizationTabPage = new System.Windows.Forms.TabPage();
+      this.pathPTSPTourView = new HeuristicLab.Problems.PTSP.Views.PathPTSPTourView();
+      ((System.ComponentModel.ISupportInitialize)(this.problemInstanceSplitContainer)).BeginInit();
+      this.problemInstanceSplitContainer.Panel1.SuspendLayout();
+      this.problemInstanceSplitContainer.Panel2.SuspendLayout();
+      this.problemInstanceSplitContainer.SuspendLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      this.tabControl.SuspendLayout();
+      this.parametersTabPage.SuspendLayout();
+      this.visualizationTabPage.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // problemInstanceSplitContainer
+      // 
+      // 
+      // problemInstanceSplitContainer.Panel2
+      // 
+      this.problemInstanceSplitContainer.Panel2.Controls.Add(this.tabControl);
+      // 
+      // parameterCollectionView
+      // 
+      this.parameterCollectionView.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)));
+      this.parameterCollectionView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.parameterCollectionView.Location = new System.Drawing.Point(3, 3);
+      this.parameterCollectionView.Size = new System.Drawing.Size(497, 274);
+      // 
+      // nameTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
+      // 
+      // tabControl
+      // 
+      this.tabControl.AllowDrop = true;
+      this.tabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.tabControl.Controls.Add(this.parametersTabPage);
+      this.tabControl.Controls.Add(this.visualizationTabPage);
+      this.tabControl.Location = new System.Drawing.Point(0, 27);
+      this.tabControl.Name = "tabControl";
+      this.tabControl.SelectedIndex = 0;
+      this.tabControl.Size = new System.Drawing.Size(511, 306);
+      this.tabControl.TabIndex = 4;
+      // 
+      // parametersTabPage
+      // 
+      this.parametersTabPage.Controls.Add(this.parameterCollectionView);
+      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
+      this.parametersTabPage.Name = "parametersTabPage";
+      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.parametersTabPage.Size = new System.Drawing.Size(503, 280);
+      this.parametersTabPage.TabIndex = 0;
+      this.parametersTabPage.Text = "Parameters";
+      this.parametersTabPage.UseVisualStyleBackColor = true;
+      // 
+      // visualizationTabPage
+      // 
+      this.visualizationTabPage.Controls.Add(this.pathPTSPTourView);
+      this.visualizationTabPage.Location = new System.Drawing.Point(4, 22);
+      this.visualizationTabPage.Name = "visualizationTabPage";
+      this.visualizationTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.visualizationTabPage.Size = new System.Drawing.Size(503, 280);
+      this.visualizationTabPage.TabIndex = 1;
+      this.visualizationTabPage.Text = "Visualization";
+      this.visualizationTabPage.UseVisualStyleBackColor = true;
+      // 
+      // pathPTSPTourView
+      // 
+      this.pathPTSPTourView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.pathPTSPTourView.Caption = "PathPTSPTour View";
+      this.pathPTSPTourView.Content = null;
+      this.pathPTSPTourView.Location = new System.Drawing.Point(6, 6);
+      this.pathPTSPTourView.Name = "pathPTSPTourView";
+      this.pathPTSPTourView.ReadOnly = false;
+      this.pathPTSPTourView.Size = new System.Drawing.Size(491, 268);
+      this.pathPTSPTourView.TabIndex = 0;
+      // 
+      // ProbabilisticTravelingSalesmanProblemView
+      // 
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+      this.Name = "ProbabilisticTravelingSalesmanProblemView";
+      this.problemInstanceSplitContainer.Panel1.ResumeLayout(false);
+      this.problemInstanceSplitContainer.Panel1.PerformLayout();
+      this.problemInstanceSplitContainer.Panel2.ResumeLayout(false);
+      this.problemInstanceSplitContainer.Panel2.PerformLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.problemInstanceSplitContainer)).EndInit();
+      this.problemInstanceSplitContainer.ResumeLayout(false);
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.tabControl.ResumeLayout(false);
+      this.parametersTabPage.ResumeLayout(false);
+      this.visualizationTabPage.ResumeLayout(false);
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private HeuristicLab.MainForm.WindowsForms.DragOverTabControl tabControl;
+    private System.Windows.Forms.TabPage parametersTabPage;
+    private System.Windows.Forms.TabPage visualizationTabPage;
+    private PathPTSPTourView pathPTSPTourView;
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/ProbabilisticTravelingSalesmanProblemView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/ProbabilisticTravelingSalesmanProblemView.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/ProbabilisticTravelingSalesmanProblemView.cs	(revision 13484)
@@ -0,0 +1,86 @@
+#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.Data;
+using HeuristicLab.MainForm;
+using HeuristicLab.Optimization.Views;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.PTSP.Views {
+  /// <summary>
+  /// A view for a Traveling Salesman Problem instance.
+  /// </summary>
+  [View("Probabilistic Traveling Salesman Problem View")]
+  [Content(typeof(ProbabilisticTravelingSalesmanProblem), true)]
+  public sealed partial class ProbabilisticTravelingSalesmanProblemView : ProblemView {
+    public new ProbabilisticTravelingSalesmanProblem Content {
+      get { return (ProbabilisticTravelingSalesmanProblem)base.Content; }
+      set { base.Content = value; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ProbabilisticTravelingSalesmanProblemView"/>.
+    /// </summary>
+    public ProbabilisticTravelingSalesmanProblemView() {
+      InitializeComponent();
+    }
+
+    protected override void DeregisterContentEvents() {
+      Content.CoordinatesParameter.ValueChanged -= CoordinatesParameter_ValueChanged;
+      Content.ProbabilitiesParameter.ValueChanged -= ProbabilityParameter_ValueChanged;
+      Content.BestKnownSolutionParameter.ValueChanged -= BestKnownSolutionParameter_ValueChanged;
+      base.DeregisterContentEvents();
+    }
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.CoordinatesParameter.ValueChanged += CoordinatesParameter_ValueChanged;
+      Content.ProbabilitiesParameter.ValueChanged += ProbabilityParameter_ValueChanged;
+      Content.BestKnownSolutionParameter.ValueChanged += BestKnownSolutionParameter_ValueChanged;
+    }
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+        pathPTSPTourView.Content = null;
+      } else {
+        pathPTSPTourView.Content = new PathPTSPTour(Content.Coordinates, Content.Probabilities, Content.BestKnownSolution, new DoubleValue(Content.BestKnownQuality));
+      }
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      pathPTSPTourView.Enabled = Content != null;
+    }
+
+    private void CoordinatesParameter_ValueChanged(object sender, EventArgs e) {
+      pathPTSPTourView.Content.Coordinates = Content.Coordinates;
+    }
+    private void ProbabilityParameter_ValueChanged(object sender, EventArgs e) {
+      pathPTSPTourView.Content.Probabilities = Content.Probabilities;
+    }
+    private void BestKnownSolutionParameter_ValueChanged(object sender, EventArgs e) {
+      pathPTSPTourView.Content.Permutation = Content.BestKnownSolution;
+      if (Content.BestKnownSolution != null)
+        pathPTSPTourView.Content.Quality = new DoubleValue(Content.Evaluate(Content.BestKnownSolution, new MersenneTwister(13)));
+      else pathPTSPTourView.Content.Quality = null;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/Properties/AssemblyInfo.cs.frame	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP.Views/3.3/Properties/AssemblyInfo.cs.frame	(revision 13484)
@@ -0,0 +1,36 @@
+﻿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.Problems.PTSP.Views")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2015 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("f26124c8-f9ae-4c86-9c42-d4a1898df780")]
+
+// 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 Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.13.$WCREV$")]
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/AnalyticalPTSP.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/AnalyticalPTSP.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/AnalyticalPTSP.cs	(revision 13484)
@@ -0,0 +1,107 @@
+﻿#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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Analytical Probabilistic Traveling Salesman Problem (PTSP)", "Represents a probabilistic traveling salesman problem where the expected tour length is calculated exactly.")]
+  [Creatable(CreatableAttribute.Categories.CombinatorialProblems)]
+  [StorableClass]
+  public sealed class AnalyticalProbabilisticTravelingSalesmanProblem : ProbabilisticTravelingSalesmanProblem {
+
+    [StorableConstructor]
+    private AnalyticalProbabilisticTravelingSalesmanProblem(bool deserializing) : base(deserializing) { }
+    private AnalyticalProbabilisticTravelingSalesmanProblem(AnalyticalProbabilisticTravelingSalesmanProblem original, Cloner cloner) : base(original, cloner) { }
+    public AnalyticalProbabilisticTravelingSalesmanProblem() {
+      Operators.Add(new BestPTSPSolutionAnalyzer());
+
+      Operators.Add(new PTSPAnalyticalInversionMoveEvaluator());
+      Operators.Add(new PTSPAnalyticalInsertionMoveEvaluator());
+      Operators.Add(new PTSPAnalyticalInversionLocalImprovement());
+      Operators.Add(new PTSPAnalyticalInsertionLocalImprovement());
+      Operators.Add(new PTSPAnalyticalTwoPointFiveLocalImprovement());
+
+      Operators.Add(new ExhaustiveTwoPointFiveMoveGenerator());
+      Operators.Add(new StochasticTwoPointFiveMultiMoveGenerator());
+      Operators.Add(new StochasticTwoPointFiveSingleMoveGenerator());
+      Operators.Add(new TwoPointFiveMoveMaker());
+      Operators.Add(new PTSPAnalyticalTwoPointFiveMoveEvaluator());
+
+      Operators.RemoveAll(x => x is SingleObjectiveMoveGenerator);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveMaker);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveEvaluator);
+
+      Encoding.ConfigureOperators(Operators.OfType<IOperator>());
+      foreach (var twopointfiveMoveOperator in Operators.OfType<ITwoPointFiveMoveOperator>()) {
+        twopointfiveMoveOperator.TwoPointFiveMoveParameter.ActualName = "Permutation.TwoPointFiveMove";
+      }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AnalyticalProbabilisticTravelingSalesmanProblem(this, cloner);
+    }
+
+    public override double Evaluate(Permutation tour, IRandom random) {
+      // abeham: Cache in local variable for performance reasons
+      var distanceMatrix = DistanceMatrix;
+      return Evaluate(tour, (a, b) => distanceMatrix[a, b], Probabilities);
+    }
+
+    public static double Evaluate(Permutation tour, Func<int, int, double> distance, DoubleArray probabilities) {
+      // Analytical evaluation
+      var firstSum = 0.0;
+      for (var i = 0; i < tour.Length - 1; i++) {
+        for (var j = i + 1; j < tour.Length; j++) {
+          var prod1 = distance(tour[i], tour[j]) * probabilities[tour[i]] * probabilities[tour[j]];
+          for (var k = i + 1; k < j; k++) {
+            prod1 = prod1 * (1 - probabilities[tour[k]]);
+          }
+          firstSum += prod1;
+        }
+      }
+      var secondSum = 0.0;
+      for (var j = 0; j < tour.Length; j++) {
+        for (var i = 0; i < j; i++) {
+          var prod2 = distance(tour[j], tour[i]) * probabilities[tour[i]] * probabilities[tour[j]];
+          for (var k = j + 1; k < tour.Length; k++) {
+            prod2 = prod2 * (1 - probabilities[tour[k]]);
+          }
+          for (var k = 0; k < i; k++) {
+            prod2 = prod2 * (1 - probabilities[tour[k]]);
+          }
+          secondSum += prod2;
+        }
+      }
+      return firstSum + secondSum;
+    }
+
+    public static double Evaluate(Permutation tour, DistanceMatrix distanceMatrix, DoubleArray probabilities) {
+      return Evaluate(tour, (a, b) => distanceMatrix[a, b], probabilities);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Analyzers/BestPTSPSolutionAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Analyzers/BestPTSPSolutionAnalyzer.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Analyzers/BestPTSPSolutionAnalyzer.cs	(revision 13484)
@@ -0,0 +1,126 @@
+﻿#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.Linq;
+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;
+
+namespace HeuristicLab.Problems.PTSP {
+  /// <summary>
+  /// An operator for analyzing the best solution of probabilistic traveling salesman problems given in path representation.
+  /// </summary>
+  [Item("BestPTSPSolutionAnalyzer", "An operator for analyzing the best solution of Probabilistic Traveling Salesman Problems given in path representation using city coordinates.")]
+  [StorableClass]
+  public sealed class BestPTSPSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator {
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    }
+    public IScopeTreeLookupParameter<Permutation> PermutationParameter {
+      get { return (IScopeTreeLookupParameter<Permutation>)Parameters["Permutation"]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleArray> ProbabilitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Probabilities"]; }
+    }
+    public ILookupParameter<PathPTSPTour> BestSolutionParameter {
+      get { return (ILookupParameter<PathPTSPTour>)Parameters["BestSolution"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+    public ILookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    public ILookupParameter<Permutation> BestKnownSolutionParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["BestKnownSolution"]; }
+    }
+
+    [StorableConstructor]
+    private BestPTSPSolutionAnalyzer(bool deserializing) : base(deserializing) { }
+    private BestPTSPSolutionAnalyzer(BestPTSPSolutionAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BestPTSPSolutionAnalyzer(this, cloner);
+    }
+    public BestPTSPSolutionAnalyzer()
+      : base() {
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the cities."));
+      Parameters.Add(new ScopeTreeLookupParameter<Permutation>("Permutation", "The PTSP solutions given in path representation from which the best solution should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the PTSP solutions which should be analyzed."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Probabilities", "This list describes for each city the probability of appearing in a realized instance."));
+      Parameters.Add(new LookupParameter<PathPTSPTour>("BestSolution", "The best PTSP solution."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the best PTSP solution should be stored."));
+      Parameters.Add(new LookupParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this PTSP instance."));
+      Parameters.Add(new LookupParameter<Permutation>("BestKnownSolution", "The best known solution of this PTSP instance."));
+    }
+
+    public override IOperation Apply() {
+      var coordinates = CoordinatesParameter.ActualValue;
+      var permutations = PermutationParameter.ActualValue;
+      var qualities = QualityParameter.ActualValue;
+      var probabilities = ProbabilitiesParameter.ActualValue;
+      var results = ResultsParameter.ActualValue;
+      var max = MaximizationParameter.ActualValue.Value;
+      var bestKnownQuality = BestKnownQualityParameter.ActualValue;
+
+      var i = !max ? qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index
+                   : qualities.Select((x, index) => new { index, x.Value }).OrderByDescending(x => x.Value).First().index;
+
+      if (bestKnownQuality == null ||
+          max && qualities[i].Value > bestKnownQuality.Value ||
+          !max && qualities[i].Value < bestKnownQuality.Value) {
+        BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[i].Value);
+        BestKnownSolutionParameter.ActualValue = (Permutation)permutations[i].Clone();
+      }
+
+      var tour = BestSolutionParameter.ActualValue;
+      if (tour == null) {
+        tour = new PathPTSPTour(coordinates, probabilities, (Permutation)permutations[i].Clone(), new DoubleValue(qualities[i].Value));
+        BestSolutionParameter.ActualValue = tour;
+        results.Add(new Result("Best PTSP Solution", tour));
+      } else {
+        if (max && tour.Quality.Value < qualities[i].Value ||
+          !max && tour.Quality.Value > qualities[i].Value) {
+          tour.Coordinates = coordinates;
+          tour.Permutation = (Permutation)permutations[i].Clone();
+          tour.Quality.Value = qualities[i].Value;
+        }
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/AttDistance.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/AttDistance.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/AttDistance.cs	(revision 13484)
@@ -0,0 +1,46 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Att Distance", "Calculates the att distance.")]
+  [StorableClass]
+  public sealed class AttDistance : DistanceCalculator {
+
+    [StorableConstructor]
+    private AttDistance(bool deserializing) : base(deserializing) { }
+    private AttDistance(AttDistance original, Cloner cloner) : base(original, cloner) { }
+    public AttDistance() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AttDistance(this, cloner);
+    }
+
+    public override double Calculate(int from, int to, DoubleMatrix coordinates) {
+      return DistanceHelper.GetDistance(DistanceMeasure.Att, coordinates[from, 0], coordinates[from, 1], coordinates[to, 0], coordinates[to, 1]);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/DistanceCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/DistanceCalculator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/DistanceCalculator.cs	(revision 13484)
@@ -0,0 +1,38 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Distance calculator", "Calculates the distance between two cities given as index of a coordinates matrix.")]
+  [StorableClass]
+  public abstract class DistanceCalculator : Item {
+    [StorableConstructor]
+    protected DistanceCalculator(bool deserializing) : base(deserializing) { }
+    protected DistanceCalculator(DistanceCalculator original, Cloner cloner) : base(original, cloner) { }
+    protected DistanceCalculator() { }
+
+    public abstract double Calculate(int from, int to, DoubleMatrix coordinates);
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/EuclideanDistance.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/EuclideanDistance.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/EuclideanDistance.cs	(revision 13484)
@@ -0,0 +1,46 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Euclidean Distance", "Calculates the euclidean distance.")]
+  [StorableClass]
+  public sealed class EuclideanDistance : DistanceCalculator {
+
+    [StorableConstructor]
+    private EuclideanDistance(bool deserializing) : base(deserializing) { }
+    private EuclideanDistance(EuclideanDistance original, Cloner cloner) : base(original, cloner) { }
+    public EuclideanDistance() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EuclideanDistance(this, cloner);
+    }
+
+    public override double Calculate(int from, int to, DoubleMatrix coordinates) {
+      return DistanceHelper.GetDistance(DistanceMeasure.Euclidean, coordinates[from, 0], coordinates[from, 1], coordinates[to, 0], coordinates[to, 1]);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/GeoDistance.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/GeoDistance.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/GeoDistance.cs	(revision 13484)
@@ -0,0 +1,46 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Geo Distance", "Calculates the geo distance.")]
+  [StorableClass]
+  public sealed class GeoDistance : DistanceCalculator {
+
+    [StorableConstructor]
+    private GeoDistance(bool deserializing) : base(deserializing) { }
+    private GeoDistance(GeoDistance original, Cloner cloner) : base(original, cloner) { }
+    public GeoDistance() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GeoDistance(this, cloner);
+    }
+
+    public override double Calculate(int from, int to, DoubleMatrix coordinates) {
+      return DistanceHelper.GetDistance(DistanceMeasure.Geo, coordinates[from, 0], coordinates[from, 1], coordinates[to, 0], coordinates[to, 1]);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/ManhattanDistance.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/ManhattanDistance.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/ManhattanDistance.cs	(revision 13484)
@@ -0,0 +1,46 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Manhattan Distance", "Calculates the Manhattan distance.")]
+  [StorableClass]
+  public sealed class ManhattanDistance : DistanceCalculator {
+
+    [StorableConstructor]
+    private ManhattanDistance(bool deserializing) : base(deserializing) { }
+    private ManhattanDistance(ManhattanDistance original, Cloner cloner) : base(original, cloner) { }
+    public ManhattanDistance() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ManhattanDistance(this, cloner);
+    }
+
+    public override double Calculate(int from, int to, DoubleMatrix coordinates) {
+      return DistanceHelper.GetDistance(DistanceMeasure.Manhattan, coordinates[from, 0], coordinates[from, 1], coordinates[to, 0], coordinates[to, 1]);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/MaximumDistance.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/MaximumDistance.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/MaximumDistance.cs	(revision 13484)
@@ -0,0 +1,46 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Maximum Distance", "Calculates the maximum distance.")]
+  [StorableClass]
+  public sealed class MaximumDistance : DistanceCalculator {
+
+    [StorableConstructor]
+    private MaximumDistance(bool deserializing) : base(deserializing) { }
+    private MaximumDistance(MaximumDistance original, Cloner cloner) : base(original, cloner) { }
+    public MaximumDistance() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MaximumDistance(this, cloner);
+    }
+
+    public override double Calculate(int from, int to, DoubleMatrix coordinates) {
+      return DistanceHelper.GetDistance(DistanceMeasure.Maximum, coordinates[from, 0], coordinates[from, 1], coordinates[to, 0], coordinates[to, 1]);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/RoundedEuclideanDistance.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/RoundedEuclideanDistance.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/RoundedEuclideanDistance.cs	(revision 13484)
@@ -0,0 +1,46 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Rounded Euclidean Distance", "Calculates the euclidean distance and rounds it to the nearest integer.")]
+  [StorableClass]
+  public sealed class RoundedEuclideanDistance : DistanceCalculator {
+
+    [StorableConstructor]
+    private RoundedEuclideanDistance(bool deserializing) : base(deserializing) { }
+    private RoundedEuclideanDistance(RoundedEuclideanDistance original, Cloner cloner) : base(original, cloner) { }
+    public RoundedEuclideanDistance() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedEuclideanDistance(this, cloner);
+    }
+
+    public override double Calculate(int from, int to, DoubleMatrix coordinates) {
+      return DistanceHelper.GetDistance(DistanceMeasure.RoundedEuclidean, coordinates[from, 0], coordinates[from, 1], coordinates[to, 0], coordinates[to, 1]);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/UpperEuclideanDistance.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/UpperEuclideanDistance.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceCalculators/UpperEuclideanDistance.cs	(revision 13484)
@@ -0,0 +1,46 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Upper Euclidean Distance", "Calculates the ceiling of the euclidean distance.")]
+  [StorableClass]
+  public sealed class UpperEuclideanDistance : DistanceCalculator {
+
+    [StorableConstructor]
+    private UpperEuclideanDistance(bool deserializing) : base(deserializing) { }
+    private UpperEuclideanDistance(UpperEuclideanDistance original, Cloner cloner) : base(original, cloner) { }
+    public UpperEuclideanDistance() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UpperEuclideanDistance(this, cloner);
+    }
+
+    public override double Calculate(int from, int to, DoubleMatrix coordinates) {
+      return DistanceHelper.GetDistance(DistanceMeasure.UpperEuclidean, coordinates[from, 0], coordinates[from, 1], coordinates[to, 0], coordinates[to, 1]);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceMatrix.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceMatrix.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/DistanceMatrix.cs	(revision 13484)
@@ -0,0 +1,48 @@
+﻿#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.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("DistanceMatrix", "Represents a distance matrix of a Probabilistic Traveling Salesman Problem.")]
+  [StorableClass]
+  public sealed class DistanceMatrix : DoubleMatrix {
+    [StorableConstructor]
+    private DistanceMatrix(bool deserializing) : base(deserializing) { }
+    public DistanceMatrix() : base() { }
+    public DistanceMatrix(int rows, int columns) : base(rows, columns) { }
+    public DistanceMatrix(int rows, int columns, IEnumerable<string> columnNames) : base(rows, columns, columnNames) { }
+    public DistanceMatrix(int rows, int columns, IEnumerable<string> columnNames, IEnumerable<string> rowNames) : base(rows, columns, columnNames, rowNames) { }
+    public DistanceMatrix(double[,] elements) : base(elements) { }
+    public DistanceMatrix(double[,] elements, IEnumerable<string> columnNames) : base(elements, columnNames) { }
+    public DistanceMatrix(double[,] elements, IEnumerable<string> columnNames, IEnumerable<string> rowNames) : base(elements, columnNames, rowNames) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      // distance matrices are not cloned for performance reasons
+      cloner.RegisterClonedObject(this, this);
+      return this;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/EstimatedPTSP.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/EstimatedPTSP.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/EstimatedPTSP.cs	(revision 13484)
@@ -0,0 +1,224 @@
+﻿#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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Estimated Probabilistic Traveling Salesman Problem (PTSP)", "Represents a probabilistic traveling salesman problem where the expected tour length is estimated by averaging over the length of tours on a number of, so called, realizations.")]
+  [Creatable(CreatableAttribute.Categories.CombinatorialProblems)]
+  [StorableClass]
+  public sealed class EstimatedProbabilisticTravelingSalesmanProblem : ProbabilisticTravelingSalesmanProblem {
+
+    #region Parameter Properties
+    public IValueParameter<ItemList<BoolArray>> RealizationsParameter {
+      get { return (IValueParameter<ItemList<BoolArray>>)Parameters["Realizations"]; }
+    }
+    public IFixedValueParameter<IntValue> RealizationsSizeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["RealizationsSize"]; }
+    }
+    #endregion
+
+    #region Properties
+    public ItemList<BoolArray> Realizations {
+      get { return RealizationsParameter.Value; }
+      set { RealizationsParameter.Value = value; }
+    }
+
+    public int RealizationsSize {
+      get { return RealizationsSizeParameter.Value.Value; }
+      set { RealizationsSizeParameter.Value.Value = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private EstimatedProbabilisticTravelingSalesmanProblem(bool deserializing) : base(deserializing) { }
+    private EstimatedProbabilisticTravelingSalesmanProblem(EstimatedProbabilisticTravelingSalesmanProblem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
+    public EstimatedProbabilisticTravelingSalesmanProblem() {
+      Parameters.Add(new FixedValueParameter<IntValue>("RealizationsSize", "Size of the sample for the estimation-based evaluation", new IntValue(100)));
+      Parameters.Add(new ValueParameter<ItemList<BoolArray>>("Realizations", "The list of samples drawn from all possible stochastic instances.", new ItemList<BoolArray>()));
+
+      Operators.Add(new BestPTSPSolutionAnalyzer());
+
+      Operators.Add(new PTSPEstimatedInversionMoveEvaluator());
+      Operators.Add(new PTSPEstimatedInsertionMoveEvaluator());
+      Operators.Add(new PTSPEstimatedInversionLocalImprovement());
+      Operators.Add(new PTSPEstimatedInsertionLocalImprovement());
+      Operators.Add(new PTSPEstimatedTwoPointFiveLocalImprovement());
+
+      Operators.Add(new ExhaustiveTwoPointFiveMoveGenerator());
+      Operators.Add(new StochasticTwoPointFiveMultiMoveGenerator());
+      Operators.Add(new StochasticTwoPointFiveSingleMoveGenerator());
+      Operators.Add(new TwoPointFiveMoveMaker());
+      Operators.Add(new PTSPEstimatedTwoPointFiveMoveEvaluator());
+
+      Operators.RemoveAll(x => x is SingleObjectiveMoveGenerator);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveMaker);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveEvaluator);
+
+      Encoding.ConfigureOperators(Operators.OfType<IOperator>());
+      foreach (var twopointfiveMoveOperator in Operators.OfType<ITwoPointFiveMoveOperator>()) {
+        twopointfiveMoveOperator.TwoPointFiveMoveParameter.ActualName = "Permutation.TwoPointFiveMove";
+      }
+
+      UpdateRealizations();
+      RegisterEventHandlers();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EstimatedProbabilisticTravelingSalesmanProblem(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    private void RegisterEventHandlers() {
+      RealizationsSizeParameter.Value.ValueChanged += RealizationsSizeParameter_ValueChanged;
+    }
+
+    private void RealizationsSizeParameter_ValueChanged(object sender, EventArgs e) {
+      UpdateRealizations();
+    }
+
+    public override double Evaluate(Permutation tour, IRandom random) {
+      // abeham: Cache parameters in local variables for performance reasons
+      var realizations = Realizations;
+      var realizationsSize = RealizationsSize;
+      var useDistanceMatrix = UseDistanceMatrix;
+      var distanceMatrix = DistanceMatrix;
+      var distanceCalculator = DistanceCalculator;
+      var coordinates = Coordinates;
+
+      // Estimation-based evaluation, here without calculating variance for faster evaluation
+      var estimatedSum = 0.0;
+      for (var i = 0; i < realizations.Count; i++) {
+        int singleRealization = -1, firstNode = -1;
+        for (var j = 0; j < realizations[i].Length; j++) {
+          if (realizations[i][tour[j]]) {
+            if (singleRealization != -1) {
+              estimatedSum += useDistanceMatrix ? distanceMatrix[singleRealization, tour[j]] : distanceCalculator.Calculate(singleRealization, tour[j], coordinates);
+            } else {
+              firstNode = tour[j];
+            }
+            singleRealization = tour[j];
+          }
+        }
+        if (singleRealization != -1) {
+          estimatedSum += useDistanceMatrix ? distanceMatrix[singleRealization, firstNode] : distanceCalculator.Calculate(singleRealization, firstNode, coordinates);
+        }
+      }
+      return estimatedSum / realizationsSize;
+    }
+
+    /// <summary>
+    /// An evaluate method that can be used if mean as well as variance should be calculated
+    /// </summary>
+    /// <param name="tour">The tour between all cities.</param>
+    /// <param name="distanceMatrix">The distances between the cities.</param>
+    /// <param name="realizations">A sample of realizations of the stochastic instance</param>
+    /// <param name="variance">The estimated variance will be returned in addition to the mean.</param>
+    /// <returns>A vector with length two containing mean and variance.</returns>
+    public static double Evaluate(Permutation tour, DistanceMatrix distanceMatrix, ItemList<BoolArray> realizations, out double variance) {
+      return Evaluate(tour, (a, b) => distanceMatrix[a, b], realizations, out variance);
+    }
+
+    /// <summary>
+    /// An evaluate method that can be used if mean as well as variance should be calculated
+    /// </summary>
+    /// <param name="tour">The tour between all cities.</param>
+    /// <param name="distance">A func that accepts the index of two cities and returns the distance as a double.</param>
+    /// <param name="realizations">A sample of realizations of the stochastic instance</param>
+    /// <param name="variance">The estimated variance will be returned in addition to the mean.</param>
+    /// <returns>A vector with length two containing mean and variance.</returns>
+    public static double Evaluate(Permutation tour, Func<int, int, double> distance, ItemList<BoolArray> realizations, out double variance) {
+      // Estimation-based evaluation
+      var estimatedSum = 0.0;
+      var partialSums = new double[realizations.Count];
+      for (var i = 0; i < realizations.Count; i++) {
+        partialSums[i] = 0;
+        int singleRealization = -1, firstNode = -1;
+        for (var j = 0; j < realizations[i].Length; j++) {
+          if (realizations[i][tour[j]]) {
+            if (singleRealization != -1) {
+              partialSums[i] += distance(singleRealization, tour[j]);
+            } else {
+              firstNode = tour[j];
+            }
+            singleRealization = tour[j];
+          }
+        }
+        if (singleRealization != -1) {
+          partialSums[i] += distance(singleRealization, firstNode);
+        }
+        estimatedSum += partialSums[i];
+      }
+      var mean = estimatedSum / realizations.Count;
+      variance = 0.0;
+      for (var i = 0; i < realizations.Count; i++) {
+        variance += Math.Pow((partialSums[i] - mean), 2);
+      }
+      variance = variance / realizations.Count;
+      return mean;
+    }
+
+    public override void Load(PTSPData data) {
+      base.Load(data);
+      UpdateRealizations();
+
+      foreach (var op in Operators.OfType<IEstimatedPTSPOperator>()) {
+        op.RealizationsParameter.ActualName = RealizationsParameter.Name;
+      }
+    }
+
+    private void UpdateRealizations() {
+      var realizations = new ItemList<BoolArray>(RealizationsSize);
+      var rand = new MersenneTwister();
+      for (var i = 0; i < RealizationsSize; i++) {
+        var newRealization = new BoolArray(Probabilities.Length);
+        var countOnes = 0;
+        do {
+          countOnes = 0;
+          for (var j = 0; j < Probabilities.Length; j++) {
+            newRealization[j] = Probabilities[j] < rand.NextDouble();
+            if (newRealization[j]) countOnes++;
+          }
+          // only generate realizations with at least 4 cities visited
+        } while (countOnes < 4 && Probabilities.Length > 3);
+        realizations.Add(newRealization);
+      }
+      Realizations = realizations;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/HeuristicLab.Problems.PTSP-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/HeuristicLab.Problems.PTSP-3.3.csproj	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/HeuristicLab.Problems.PTSP-3.3.csproj	(revision 13484)
@@ -0,0 +1,223 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{97198965-AFEA-496B-B3B1-316905C43FD6}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.PTSP</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.PTSP-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
+      <Project>{0E27A536-1C4A-4624-A65E-DC4F4F23E3E1}</Project>
+      <Name>HeuristicLab.Common.Resources-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.PermutationEncoding\3.3\HeuristicLab.Encodings.PermutationEncoding-3.3.csproj">
+      <Project>{DBECB8B0-B166-4133-BAF1-ED67C3FD7FCA}</Project>
+      <Name>HeuristicLab.Encodings.PermutationEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
+      <Project>{23DA7FF4-D5B8-41B6-AA96-F0561D24F3EE}</Project>
+      <Name>HeuristicLab.Operators-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>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.Instances\3.3\HeuristicLab.Problems.Instances-3.3.csproj">
+      <Project>{3540E29E-4793-49E7-8EE2-FEA7F61C3994}</Project>
+      <Name>HeuristicLab.Problems.Instances-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
+      <Project>{F4539FB6-4708-40C9-BE64-0A1390AEA197}</Project>
+      <Name>HeuristicLab.Random-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.IO.Compression" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="AnalyticalPTSP.cs" />
+    <Compile Include="Analyzers\BestPTSPSolutionAnalyzer.cs" />
+    <Compile Include="DistanceCalculators\MaximumDistance.cs" />
+    <Compile Include="DistanceCalculators\ManhattanDistance.cs" />
+    <Compile Include="DistanceCalculators\GeoDistance.cs" />
+    <Compile Include="DistanceCalculators\DistanceCalculator.cs" />
+    <Compile Include="DistanceCalculators\AttDistance.cs" />
+    <Compile Include="DistanceCalculators\UpperEuclideanDistance.cs" />
+    <Compile Include="DistanceCalculators\RoundedEuclideanDistance.cs" />
+    <Compile Include="DistanceCalculators\EuclideanDistance.cs" />
+    <Compile Include="DistanceMatrix.cs" />
+    <Compile Include="EstimatedPTSP.cs" />
+    <Compile Include="Improvers\PTSPAnalyticalInsertionLocalImprovement.cs" />
+    <Compile Include="Improvers\PTSPAnalyticalTwoPointFiveLocalImprovement.cs" />
+    <Compile Include="Improvers\PTSPEstimatedInsertionLocalImprovement.cs" />
+    <Compile Include="Improvers\PTSPAnalyticalInversionLocalImprovement.cs" />
+    <Compile Include="Improvers\PTSPEstimatedTwoPointFiveLocalImprovement.cs" />
+    <Compile Include="Improvers\PTSPEstimatedInversionLocalImprovement.cs" />
+    <Compile Include="Interfaces\IAnalyticalPTSPMoveEvaluator.cs" />
+    <Compile Include="Interfaces\IAnalyticalPTSPOperator.cs" />
+    <Compile Include="Interfaces\IEstimatedPTSPOperator.cs" />
+    <Compile Include="Interfaces\ITwoPointFiveMoveOperator.cs" />
+    <Compile Include="Interfaces\IEstimatedPTSPMoveEvaluator.cs" />
+    <Compile Include="Moves\AnalyticalPTSPMoveEvaluator.cs" />
+    <Compile Include="Moves\OneShift\PTSPAnalyticalInsertionMoveEvaluator.cs" />
+    <Compile Include="Moves\OneShift\PTSPEstimatedInsertionMoveEvaluator.cs" />
+    <Compile Include="Moves\EstimatedPTSPMoveEvaluator.cs" />
+    <Compile Include="Moves\TwoOpt\PTSPAnalyticalInversionMoveEvaluator.cs" />
+    <Compile Include="Moves\TwoOpt\PTSPEstimatedInversionMoveEvaluator.cs" />
+    <Compile Include="Moves\TwoPointFiveOpt\PTSPAnalyticalTwoPointFiveMoveEvaluator.cs" />
+    <Compile Include="Moves\TwoPointFiveOpt\PTSPEstimatedTwoPointFiveMoveEvaluator.cs" />
+    <Compile Include="Moves\TwoPointFiveOpt\ExhaustiveTwoPointFiveMoveGenerator.cs" />
+    <Compile Include="Moves\TwoPointFiveOpt\StochasticTwoPointFiveMultiMoveGenerator.cs" />
+    <Compile Include="Moves\TwoPointFiveOpt\StochasticTwoPointFiveSingleMoveGenerator.cs" />
+    <Compile Include="Moves\TwoPointFiveOpt\TwoPointFiveMoveGenerator.cs" />
+    <Compile Include="Moves\TwoPointFiveOpt\TwoPointFiveMoveMaker.cs" />
+    <Compile Include="Moves\TwoPointFiveOpt\TwoPointFiveMove.cs" />
+    <Compile Include="PathPTSPTour.cs" />
+    <Compile Include="PTSP.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set OutDir=$(OutDir)
+set TargetDir=$(TargetDir)
+
+call PreBuildEvent.cmd
+    </PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
+    </PreBuildEvent>
+  </PropertyGroup>
+  <!-- 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>
+  -->
+</Project>
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPAnalyticalInsertionLocalImprovement.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPAnalyticalInsertionLocalImprovement.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPAnalyticalInsertionLocalImprovement.cs	(revision 13484)
@@ -0,0 +1,145 @@
+﻿#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.Threading;
+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;
+
+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 inserting a city in the tour between two other cities for a certain number of times.
+  /// </remarks>
+  [Item("PTSP Analytical Insertion Local Improvement", "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 PTSPAnalyticalInsertionLocalImprovement : SingleSuccessorOperator, IAnalyticalPTSPOperator, 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 ILookupParameter<DoubleArray> ProbabilitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Probabilities"]; }
+    }
+
+    [StorableConstructor]
+    private PTSPAnalyticalInsertionLocalImprovement(bool deserializing) : base(deserializing) { }
+    private PTSPAnalyticalInsertionLocalImprovement(PTSPAnalyticalInsertionLocalImprovement original, Cloner cloner) : base(original, cloner) { }
+    public PTSPAnalyticalInsertionLocalImprovement()
+      : 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 LookupParameter<DoubleArray>("Probabilities", "The list of probabilities of the cities to appear."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPAnalyticalInsertionLocalImprovement(this, cloner);
+    }
+
+    public static void Improve(Permutation assignment, DoubleMatrix distances, DoubleValue quality, IntValue localIterations, IntValue evaluatedSolutions, bool maximization, int maxIterations, DoubleArray probabilities, CancellationToken cancellation) {
+      var distanceM = (DistanceMatrix)distances;
+      Func<int, int, double> distance = (a, b) => distanceM[a, b];
+      for (var i = localIterations.Value; i < maxIterations; i++) {
+        TranslocationMove bestMove = null;
+        var bestQuality = quality.Value; // we have to make an improvement, so current quality is the baseline
+        var evaluations = 0.0;
+        foreach (var move in ExhaustiveInsertionMoveGenerator.Generate(assignment)) {
+          var moveQuality = PTSPAnalyticalInsertionMoveEvaluator.EvaluateMove(assignment, move, distance, probabilities);
+          evaluations++;
+          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 probabilities = ProbabilitiesParameter.ActualValue;
+      if (localIterations == null) {
+        localIterations = new IntValue(0);
+        LocalIterationsParameter.ActualValue = localIterations;
+      }
+
+      Improve(assignment, distances, quality, localIterations, evaluations, maximization, maxIterations, probabilities, CancellationToken);
+
+      localIterations.Value = 0;
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPAnalyticalInversionLocalImprovement.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPAnalyticalInversionLocalImprovement.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPAnalyticalInversionLocalImprovement.cs	(revision 13484)
@@ -0,0 +1,145 @@
+﻿#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.Threading;
+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;
+
+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("PTSP Analytical Inversion Local Improvement", "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 PTSPAnalyticalInversionLocalImprovement : SingleSuccessorOperator, IAnalyticalPTSPOperator, 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 ILookupParameter<DoubleArray> ProbabilitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Probabilities"]; }
+    }
+
+    [StorableConstructor]
+    private PTSPAnalyticalInversionLocalImprovement(bool deserializing) : base(deserializing) { }
+    private PTSPAnalyticalInversionLocalImprovement(PTSPAnalyticalInversionLocalImprovement original, Cloner cloner) : base(original, cloner) { }
+    public PTSPAnalyticalInversionLocalImprovement()
+      : 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 LookupParameter<DoubleArray>("Probabilities", "The list of probabilities of the cities to appear."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPAnalyticalInversionLocalImprovement(this, cloner);
+    }
+
+    public static void Improve(Permutation assignment, DoubleMatrix distances, DoubleValue quality, IntValue localIterations, IntValue evaluatedSolutions, bool maximization, int maxIterations, DoubleArray probabilities, CancellationToken cancellation) {
+      var distanceM = (DistanceMatrix)distances;
+      Func<int, int, double> distance = (a, b) => distanceM[a, b];
+      for (var i = localIterations.Value; i < maxIterations; i++) {
+        InversionMove bestMove = null;
+        var bestQuality = quality.Value; // we have to make an improvement, so current quality is the baseline
+        var evaluations = 0.0;
+        foreach (var move in ExhaustiveInversionMoveGenerator.Generate(assignment)) {
+          var moveQuality = PTSPAnalyticalInversionMoveEvaluator.EvaluateMove(assignment, move, distance, probabilities);
+          evaluations++;
+          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 probabilities = ProbabilitiesParameter.ActualValue;
+      if (localIterations == null) {
+        localIterations = new IntValue(0);
+        LocalIterationsParameter.ActualValue = localIterations;
+      }
+
+      Improve(assignment, distances, quality, localIterations, evaluations, maximization, maxIterations, probabilities, CancellationToken);
+
+      localIterations.Value = 0;
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPAnalyticalTwoPointFiveLocalImprovement.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPAnalyticalTwoPointFiveLocalImprovement.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPAnalyticalTwoPointFiveLocalImprovement.cs	(revision 13484)
@@ -0,0 +1,145 @@
+﻿#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.Threading;
+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;
+
+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("PTSP Analytical 2.5 Local Improvement", "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 PTSPAnalyticalTwoPointFiveLocalImprovement : SingleSuccessorOperator, IAnalyticalPTSPOperator, 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 ILookupParameter<DoubleArray> ProbabilitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Probabilities"]; }
+    }
+
+    [StorableConstructor]
+    private PTSPAnalyticalTwoPointFiveLocalImprovement(bool deserializing) : base(deserializing) { }
+    private PTSPAnalyticalTwoPointFiveLocalImprovement(PTSPAnalyticalTwoPointFiveLocalImprovement original, Cloner cloner) : base(original, cloner) { }
+    public PTSPAnalyticalTwoPointFiveLocalImprovement()
+      : 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 LookupParameter<DoubleArray>("Probabilities", "The list of probabilities of the cities to appear."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPAnalyticalTwoPointFiveLocalImprovement(this, cloner);
+    }
+
+    public static void Improve(Permutation assignment, DoubleMatrix distances, DoubleValue quality, IntValue localIterations, IntValue evaluatedSolutions, bool maximization, int maxIterations, DoubleArray probabilities, CancellationToken cancellation) {
+      var distanceM = (DistanceMatrix)distances;
+      Func<int, int, double> distance = (a, b) => distanceM[a, b];
+      for (var i = localIterations.Value; i < maxIterations; i++) {
+        TwoPointFiveMove bestMove = null;
+        var bestQuality = quality.Value; // we have to make an improvement, so current quality is the baseline
+        var evaluations = 0.0;
+        foreach (var move in ExhaustiveTwoPointFiveMoveGenerator.Generate(assignment)) {
+          var moveQuality = PTSPAnalyticalTwoPointFiveMoveEvaluator.EvaluateMove(assignment, move, distance, probabilities);
+          evaluations++;
+          if (maximization && moveQuality > bestQuality
+            || !maximization && moveQuality < bestQuality) {
+            bestQuality = moveQuality;
+            bestMove = move;
+          }
+        }
+        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
+        if (bestMove == null) break;
+        TwoPointFiveMoveMaker.Apply(assignment, bestMove);
+        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 probabilities = ProbabilitiesParameter.ActualValue;
+      if (localIterations == null) {
+        localIterations = new IntValue(0);
+        LocalIterationsParameter.ActualValue = localIterations;
+      }
+
+      Improve(assignment, distances, quality, localIterations, evaluations, maximization, maxIterations, probabilities, CancellationToken);
+
+      localIterations.Value = 0;
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPEstimatedInsertionLocalImprovement.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPEstimatedInsertionLocalImprovement.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPEstimatedInsertionLocalImprovement.cs	(revision 13484)
@@ -0,0 +1,145 @@
+﻿#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.Threading;
+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;
+
+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 inserting a city in the tour between two other cities for a certain number of times.
+  /// </remarks>
+  [Item("PTSP Estimated Insertion Local Improvement", "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 PTSPEstimatedInsertionLocalImprovement : SingleSuccessorOperator, IEstimatedPTSPOperator, 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 ILookupParameter<ItemList<BoolArray>> RealizationsParameter {
+      get { return (ILookupParameter<ItemList<BoolArray>>)Parameters["Realizations"]; }
+    }
+
+    [StorableConstructor]
+    private PTSPEstimatedInsertionLocalImprovement(bool deserializing) : base(deserializing) { }
+    private PTSPEstimatedInsertionLocalImprovement(PTSPEstimatedInsertionLocalImprovement original, Cloner cloner) : base(original, cloner) { }
+    public PTSPEstimatedInsertionLocalImprovement()
+      : 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 LookupParameter<ItemList<BoolArray>>("Realizations", "The list of samples drawn from all possible stochastic instances."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPEstimatedInsertionLocalImprovement(this, cloner);
+    }
+
+    public static void Improve(Permutation assignment, DoubleMatrix distances, DoubleValue quality, IntValue localIterations, IntValue evaluatedSolutions, bool maximization, int maxIterations, ItemList<BoolArray> realizations, CancellationToken cancellation) {
+      var distanceM = (DistanceMatrix)distances;
+      Func<int, int, double> distance = (a, b) => distanceM[a, b];
+      for (var 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 = PTSPEstimatedInsertionMoveEvaluator.EvaluateMove(assignment, move, distance, realizations);
+          evaluations += realizations.Count * 6.0 / (assignment.Length * 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.ActualValue;
+      if (localIterations == null) {
+        localIterations = new IntValue(0);
+        LocalIterationsParameter.ActualValue = localIterations;
+      }
+
+      Improve(assignment, distances, quality, localIterations, evaluations, maximization, maxIterations, realizations, CancellationToken);
+
+      localIterations.Value = 0;
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPEstimatedInversionLocalImprovement.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPEstimatedInversionLocalImprovement.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPEstimatedInversionLocalImprovement.cs	(revision 13484)
@@ -0,0 +1,145 @@
+﻿#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.Threading;
+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;
+
+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("PTSP Estimated Inversion Local Improvement", "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 PTSPEstimatedInversionLocalImprovement : SingleSuccessorOperator, IEstimatedPTSPOperator, 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 ILookupParameter<ItemList<BoolArray>> RealizationsParameter {
+      get { return (ILookupParameter<ItemList<BoolArray>>)Parameters["Realizations"]; }
+    }
+
+    [StorableConstructor]
+    private PTSPEstimatedInversionLocalImprovement(bool deserializing) : base(deserializing) { }
+    private PTSPEstimatedInversionLocalImprovement(PTSPEstimatedInversionLocalImprovement original, Cloner cloner) : base(original, cloner) { }
+    public PTSPEstimatedInversionLocalImprovement()
+      : 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 LookupParameter<ItemList<BoolArray>>("Realizations", "The list of samples drawn from all possible stochastic instances."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPEstimatedInversionLocalImprovement(this, cloner);
+    }
+
+    public static void Improve(Permutation assignment, DoubleMatrix distances, DoubleValue quality, IntValue localIterations, IntValue evaluatedSolutions, bool maximization, int maxIterations, ItemList<BoolArray> realizations, CancellationToken cancellation) {
+      var distanceM = (DistanceMatrix)distances;
+      Func<int, int, double> distance = (a, b) => distanceM[a, b];
+      for (var 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 = PTSPEstimatedInversionMoveEvaluator.EvaluateMove(assignment, move, distance, realizations);
+          evaluations += realizations.Count * 4.0 / (assignment.Length * 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.ActualValue;
+      if (localIterations == null) {
+        localIterations = new IntValue(0);
+        LocalIterationsParameter.ActualValue = localIterations;
+      }
+
+      Improve(assignment, distances, quality, localIterations, evaluations, maximization, maxIterations, realizations, CancellationToken);
+
+      localIterations.Value = 0;
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPEstimatedTwoPointFiveLocalImprovement.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPEstimatedTwoPointFiveLocalImprovement.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPEstimatedTwoPointFiveLocalImprovement.cs	(revision 13484)
@@ -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 System.Threading;
+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;
+
+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("PTSP Estimated 2.5 Local Improvement", "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 PTSPEstimatedTwoPointFiveLocalImprovement : SingleSuccessorOperator, IEstimatedPTSPOperator, 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 ILookupParameter<ItemList<BoolArray>> RealizationsParameter {
+      get { return (ILookupParameter<ItemList<BoolArray>>)Parameters["Realizations"]; }
+    }
+
+    [StorableConstructor]
+    private PTSPEstimatedTwoPointFiveLocalImprovement(bool deserializing) : base(deserializing) { }
+    private PTSPEstimatedTwoPointFiveLocalImprovement(PTSPEstimatedTwoPointFiveLocalImprovement original, Cloner cloner) : base(original, cloner) { }
+    public PTSPEstimatedTwoPointFiveLocalImprovement()
+      : 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 LookupParameter<ItemList<BoolArray>>("Realizations", "The list of samples drawn from all possible stochastic instances."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPEstimatedTwoPointFiveLocalImprovement(this, cloner);
+    }
+
+    public static void Improve(Permutation assignment, DoubleMatrix distances, DoubleValue quality, IntValue localIterations, IntValue evaluatedSolutions, bool maximization, int maxIterations, ItemList<BoolArray> realizations, CancellationToken cancellation) {
+      var distanceM = (DistanceMatrix)distances;
+      Func<int, int, double> distance = (a, b) => distanceM[a, b];
+      for (var i = localIterations.Value; i < maxIterations; i++) {
+        TwoPointFiveMove bestMove = null;
+        var bestQuality = 0.0; // we have to make an improvement, so 0 is the baseline
+        var evaluations = 0.0;
+        foreach (var move in ExhaustiveTwoPointFiveMoveGenerator.Generate(assignment)) {
+          var moveQuality = PTSPEstimatedTwoPointFiveMoveEvaluator.EvaluateMove(assignment, move, distance, realizations);
+          if (move.IsInvert) evaluations += realizations.Count * 4.0 / (assignment.Length * assignment.Length);
+          else evaluations += realizations.Count * 6.0 / (assignment.Length * assignment.Length);
+          if (maximization && moveQuality > bestQuality
+            || !maximization && moveQuality < bestQuality) {
+            bestQuality = moveQuality;
+            bestMove = move;
+          }
+        }
+        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
+        if (bestMove == null) break;
+        TwoPointFiveMoveMaker.Apply(assignment, bestMove);
+        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.ActualValue;
+      if (localIterations == null) {
+        localIterations = new IntValue(0);
+        LocalIterationsParameter.ActualValue = localIterations;
+      }
+
+      Improve(assignment, distances, quality, localIterations, evaluations, maximization, maxIterations, realizations, CancellationToken);
+
+      localIterations.Value = 0;
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IAnalyticalPTSPMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IAnalyticalPTSPMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IAnalyticalPTSPMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,34 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.PTSP {
+  public interface IAnalyticalPTSPMoveEvaluator : IAnalyticalPTSPOperator, ISingleObjectiveMoveEvaluator, IPermutationMoveOperator {
+    ILookupParameter<DoubleMatrix> CoordinatesParameter { get; }
+    ILookupParameter<DistanceCalculator> DistanceCalculatorParameter { get; }
+    ILookupParameter<DistanceMatrix> DistanceMatrixParameter { get; }
+    ILookupParameter<BoolValue> UseDistanceMatrixParameter { get; }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IAnalyticalPTSPOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IAnalyticalPTSPOperator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IAnalyticalPTSPOperator.cs	(revision 13484)
@@ -0,0 +1,29 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.PTSP {
+  public interface IAnalyticalPTSPOperator : IItem {
+    ILookupParameter<DoubleArray> ProbabilitiesParameter { get; }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IEstimatedPTSPMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IEstimatedPTSPMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IEstimatedPTSPMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,34 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.PTSP {
+  public interface IEstimatedPTSPMoveEvaluator : IEstimatedPTSPOperator, ISingleObjectiveMoveEvaluator, IPermutationMoveOperator {
+    ILookupParameter<DoubleMatrix> CoordinatesParameter { get; }
+    ILookupParameter<DistanceCalculator> DistanceCalculatorParameter { get; }
+    ILookupParameter<DistanceMatrix> DistanceMatrixParameter { get; }
+    ILookupParameter<BoolValue> UseDistanceMatrixParameter { get; }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IEstimatedPTSPOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IEstimatedPTSPOperator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/IEstimatedPTSPOperator.cs	(revision 13484)
@@ -0,0 +1,29 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.PTSP {
+  public interface IEstimatedPTSPOperator : IItem {
+    ILookupParameter<ItemList<BoolArray>> RealizationsParameter { get; }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/ITwoPointFiveMoveOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/ITwoPointFiveMoveOperator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Interfaces/ITwoPointFiveMoveOperator.cs	(revision 13484)
@@ -0,0 +1,29 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.PTSP {
+  public interface ITwoPointFiveMoveOperator : IMoveOperator {
+    ILookupParameter<TwoPointFiveMove> TwoPointFiveMoveParameter { get; }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/AnalyticalPTSPMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/AnalyticalPTSPMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/AnalyticalPTSPMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,106 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("AnalyticalPTSPMoveEvaluator", "A base class for operators which evaluate PTSP moves.")]
+  [StorableClass]
+  public abstract class AnalyticalPTSPMoveEvaluator : SingleSuccessorOperator, IAnalyticalPTSPMoveEvaluator {
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
+    }
+    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    }
+    public ILookupParameter<DistanceMatrix> DistanceMatrixParameter {
+      get { return (ILookupParameter<DistanceMatrix>)Parameters["DistanceMatrix"]; }
+    }
+    public ILookupParameter<BoolValue> UseDistanceMatrixParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
+    }
+    public ILookupParameter<DoubleArray> ProbabilitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Probabilities"]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<DistanceCalculator> DistanceCalculatorParameter {
+      get { return (ILookupParameter<DistanceCalculator>)Parameters["DistanceCalculator"]; }
+    }
+
+    [StorableConstructor]
+    protected AnalyticalPTSPMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected AnalyticalPTSPMoveEvaluator(AnalyticalPTSPMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    protected AnalyticalPTSPMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates", "The city's coordinates."));
+      Parameters.Add(new LookupParameter<DistanceMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
+      Parameters.Add(new LookupParameter<BoolValue>("UseDistanceMatrix", "True if a distance matrix should be calculated (if it does not exist already) and used for evaluation, otherwise false."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Probabilities", "The list of probabilities for each city to appear."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a TSP solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The evaluated quality of a move on a TSP solution."));
+      Parameters.Add(new LookupParameter<DistanceCalculator>("DistanceCalculator", "The class that can compute distances between coordinates."));
+    }
+
+    public override IOperation Apply() {
+      var permutation = PermutationParameter.ActualValue;
+      var coordinates = CoordinatesParameter.ActualValue;
+      var probabilities = ProbabilitiesParameter.ActualValue;
+      Func<int, int, double> distance = null;
+      if (UseDistanceMatrixParameter.ActualValue.Value) {
+        var distanceMatrix = DistanceMatrixParameter.ActualValue;
+        if (distanceMatrix == null) throw new InvalidOperationException("The distance matrix has not been calculated.");
+        distance = (a, b) => distanceMatrix[a, b];
+      } else {
+        if (coordinates == null) throw new InvalidOperationException("No coordinates were given.");
+        var distanceCalculator = DistanceCalculatorParameter.ActualValue;
+        if (distanceCalculator == null) throw new InvalidOperationException("Distance calculator is null!");
+        distance = (a, b) => distanceCalculator.Calculate(a, b, coordinates);
+      }
+      // here moves are not delta-evaluated
+      var newQuality = EvaluateMove(permutation, distance, probabilities);
+      var moveQuality = MoveQualityParameter.ActualValue;
+      if (moveQuality == null) MoveQualityParameter.ActualValue = new DoubleValue(newQuality);
+      else moveQuality.Value = newQuality;
+
+      return base.Apply();
+    }
+
+    protected abstract double EvaluateMove(Permutation permutation, Func<int, int, double> distance, DoubleArray probabilities);
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/EstimatedPTSPMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/EstimatedPTSPMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/EstimatedPTSPMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,104 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("EstimatedPTSPMoveEvaluator", "A base class for operators which evaluate PTSP moves.")]
+  [StorableClass]
+  public abstract class EstimatedPTSPMoveEvaluator : SingleSuccessorOperator, IEstimatedPTSPMoveEvaluator {
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
+    }
+    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    }
+    public ILookupParameter<DistanceMatrix> DistanceMatrixParameter {
+      get { return (ILookupParameter<DistanceMatrix>)Parameters["DistanceMatrix"]; }
+    }
+    public ILookupParameter<BoolValue> UseDistanceMatrixParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
+    }
+    public ILookupParameter<ItemList<BoolArray>> RealizationsParameter {
+      get { return (ILookupParameter<ItemList<BoolArray>>)Parameters["Realizations"]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<DistanceCalculator> DistanceCalculatorParameter {
+      get { return (ILookupParameter<DistanceCalculator>)Parameters["DistanceCalculator"]; }
+    }
+
+    [StorableConstructor]
+    protected EstimatedPTSPMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected EstimatedPTSPMoveEvaluator(EstimatedPTSPMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    protected EstimatedPTSPMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates", "The city's coordinates."));
+      Parameters.Add(new LookupParameter<DistanceMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
+      Parameters.Add(new LookupParameter<BoolValue>("UseDistanceMatrix", "True if a distance matrix should be calculated (if it does not exist already) and used for evaluation, otherwise false."));
+      Parameters.Add(new LookupParameter<ItemList<BoolArray>>("Realizations", "The list of samples drawn from all possible stochastic instances."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a TSP solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The evaluated quality of a move on a TSP solution."));
+      Parameters.Add(new LookupParameter<DistanceCalculator>("DistanceCalculator", "The class that can compute distances between coordinates."));
+    }
+
+    public override IOperation Apply() {
+      var permutation = PermutationParameter.ActualValue;
+      var coordinates = CoordinatesParameter.ActualValue;
+      var realizations = RealizationsParameter.ActualValue;
+      Func<int, int, double> distance = null;
+      if (UseDistanceMatrixParameter.ActualValue.Value) {
+        var distanceMatrix = DistanceMatrixParameter.ActualValue;
+        if (distanceMatrix == null) throw new InvalidOperationException("The distance matrix has not been calculated.");
+        distance = (a, b) => distanceMatrix[a, b];
+      } else {
+        if (coordinates == null) throw new InvalidOperationException("No coordinates were given.");
+        var distanceCalculator = DistanceCalculatorParameter.ActualValue;
+        if (distanceCalculator == null) throw new InvalidOperationException("Distance calculator is null!");
+        distance = (a, b) => distanceCalculator.Calculate(a, b, coordinates);
+      }
+      var relativeQualityDifference = EvaluateMove(permutation, distance, realizations);
+      var moveQuality = MoveQualityParameter.ActualValue;
+      if (moveQuality == null) MoveQualityParameter.ActualValue = new DoubleValue(QualityParameter.ActualValue.Value + relativeQualityDifference);
+      else moveQuality.Value = QualityParameter.ActualValue.Value + relativeQualityDifference;
+      return base.Apply();
+    }
+
+    protected abstract double EvaluateMove(Permutation permutation, Func<int, int, double> distance, ItemList<BoolArray> realizations);
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/OneShift/PTSPAnalyticalInsertionMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/OneShift/PTSPAnalyticalInsertionMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/OneShift/PTSPAnalyticalInsertionMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,61 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("PTSP Analytical Insertion Move Evaluator", "Evaluates an insertion move (1-shift) by a full solution evaluation")]
+  [StorableClass]
+  public class PTSPAnalyticalInsertionMoveEvaluator : AnalyticalPTSPMoveEvaluator, IPermutationTranslocationMoveOperator {
+
+    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
+      get { return (ILookupParameter<TranslocationMove>)Parameters["TranslocationMove"]; }
+    }
+
+    [StorableConstructor]
+    protected PTSPAnalyticalInsertionMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected PTSPAnalyticalInsertionMoveEvaluator(PTSPAnalyticalInsertionMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public PTSPAnalyticalInsertionMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<TranslocationMove>("TranslocationMove", "The move to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPAnalyticalInsertionMoveEvaluator(this, cloner);
+    }
+
+    public static double EvaluateMove(Permutation tour, TranslocationMove move, Func<int, int, double> distance, DoubleArray probabilities) {
+      var afterMove = (Permutation)tour.Clone();
+      TranslocationManipulator.Apply(afterMove, move.Index1, move.Index1, move.Index3);
+      return AnalyticalProbabilisticTravelingSalesmanProblem.Evaluate(afterMove, distance, probabilities);
+    }
+
+    protected override double EvaluateMove(Permutation tour, Func<int, int, double> distance, DoubleArray probabilities) {
+      return EvaluateMove(tour, TranslocationMoveParameter.ActualValue, distance, probabilities);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/OneShift/PTSPEstimatedInsertionMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/OneShift/PTSPEstimatedInsertionMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/OneShift/PTSPEstimatedInsertionMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,155 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("PTSP Estimated Insertion Move Evaluator", "Evaluates an insertion move (1-shift)")]
+  [StorableClass]
+  public class PTSPEstimatedInsertionMoveEvaluator : EstimatedPTSPMoveEvaluator, IPermutationTranslocationMoveOperator {
+
+    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
+      get { return (ILookupParameter<TranslocationMove>)Parameters["TranslocationMove"]; }
+    }
+
+    [StorableConstructor]
+    protected PTSPEstimatedInsertionMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected PTSPEstimatedInsertionMoveEvaluator(PTSPEstimatedInsertionMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public PTSPEstimatedInsertionMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<TranslocationMove>("TranslocationMove", "The move to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPEstimatedInsertionMoveEvaluator(this, cloner);
+    }
+
+    public static double EvaluateMove(Permutation tour, TranslocationMove move, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
+      var afterMove = (Permutation)tour.Clone();
+      TranslocationManipulator.Apply(afterMove, move.Index1, move.Index1, move.Index3);
+      double moveQuality = 0;
+      var edges = new int[12];
+      var indices = new int[12];
+      edges[0] = tour.GetCircular(move.Index1 - 1);
+      indices[0] = DecreaseCircularIndex(tour.Length, move.Index1);
+      edges[1] = tour[move.Index1];
+      indices[1] = move.Index1;
+      edges[2] = tour[move.Index1];
+      indices[2] = move.Index1;
+      edges[3] = tour.GetCircular(move.Index1 + 1);
+      indices[3] = IncreaseCircularIndex(tour.Length, move.Index1);
+
+      edges[6] = afterMove.GetCircular(move.Index3 - 1);
+      indices[6] = DecreaseCircularIndex(afterMove.Length, move.Index3);
+      edges[7] = afterMove[move.Index3];
+      indices[7] = move.Index3;
+      edges[8] = afterMove[move.Index3];
+      indices[8] = move.Index3;
+      edges[9] = afterMove.GetCircular(move.Index3 + 1);
+      indices[9] = IncreaseCircularIndex(afterMove.Length, move.Index3);
+
+      if (move.Index3 > move.Index1) {
+        edges[4] = tour[move.Index3];
+        indices[4] = move.Index3;
+        edges[5] = tour.GetCircular(move.Index3 + 1);
+        indices[5] = indices[9];
+        edges[10] = afterMove.GetCircular(move.Index1 - 1);
+        indices[10] = indices[0];
+        edges[11] = afterMove[move.Index1];
+        indices[11] = move.Index1;
+      } else {
+        edges[4] = tour.GetCircular(move.Index3 - 1);
+        indices[4] = indices[6];
+        edges[5] = tour[move.Index3];
+        indices[5] = move.Index3;
+        edges[10] = afterMove[move.Index1];
+        indices[10] = move.Index1;
+        edges[11] = afterMove.GetCircular(move.Index1 + 1);
+        indices[11] = indices[3];
+      }
+      int[] aPosteriori = new int[12];
+      foreach (var realization in realizations) {
+        for (int i = 0; i < edges.Length; i++) {
+          Permutation tempPermutation;
+          if (i < 6) {
+            tempPermutation = tour;
+          } else {
+            tempPermutation = afterMove;
+          }
+          if (realization[edges[i]]) {
+            aPosteriori[i] = edges[i];
+          } else {
+            int j = 1;
+            if (i % 2 == 0) {
+              // find nearest predecessor in realization if source edge
+              while (!realization[tempPermutation.GetCircular(indices[i] - j)]) {
+                j++;
+              }
+              aPosteriori[i] = tempPermutation.GetCircular(indices[i] - j);
+            } else {
+              // find nearest successor in realization if target edge
+              while (!realization[tempPermutation.GetCircular(indices[i] + j)]) {
+                j++;
+              }
+              aPosteriori[i] = tempPermutation.GetCircular(indices[i] + j);
+            }
+          }
+        }
+        if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3]) &&
+          !(aPosteriori[0] == aPosteriori[4] && aPosteriori[1] == aPosteriori[5]) &&
+          !(aPosteriori[2] == aPosteriori[4] && aPosteriori[3] == aPosteriori[5])) {
+          // compute cost difference between the two a posteriori solutions
+          moveQuality = moveQuality + distance(aPosteriori[6], aPosteriori[7]) + distance(aPosteriori[8], aPosteriori[9]) + distance(aPosteriori[10], aPosteriori[11]);
+          moveQuality = moveQuality - distance(aPosteriori[0], aPosteriori[1]) - distance(aPosteriori[2], aPosteriori[3]) - distance(aPosteriori[4], aPosteriori[5]);
+        }
+        Array.Clear(aPosteriori, 0, aPosteriori.Length);
+      }
+      // return average of cost differences
+      return moveQuality / realizations.Count;
+    }
+
+    private static int DecreaseCircularIndex(int length, int index) {
+      var result = index - 1;
+      if (result == -1) {
+        result = length - 1;
+      }
+      return result;
+    }
+
+    private static int IncreaseCircularIndex(int length, int index) {
+      var result = index + 1;
+      if (result == length + 1) {
+        result = 0;
+      }
+      return result;
+    }
+
+    protected override double EvaluateMove(Permutation tour, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
+      return EvaluateMove(tour, TranslocationMoveParameter.ActualValue, distance, realizations);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoOpt/PTSPAnalyticalInversionMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoOpt/PTSPAnalyticalInversionMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoOpt/PTSPAnalyticalInversionMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,61 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("PTSP Analytical Inversion Move Evaluator", "Evaluates an inversion move (2-opt) by a full solution evaluation.")]
+  [StorableClass]
+  public class PTSPAnalyticalInversionMoveEvaluator : AnalyticalPTSPMoveEvaluator, IPermutationInversionMoveOperator {
+
+    public ILookupParameter<InversionMove> InversionMoveParameter {
+      get { return (ILookupParameter<InversionMove>)Parameters["InversionMove"]; }
+    }
+
+    [StorableConstructor]
+    protected PTSPAnalyticalInversionMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected PTSPAnalyticalInversionMoveEvaluator(PTSPAnalyticalInversionMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public PTSPAnalyticalInversionMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<InversionMove>("InversionMove", "The move to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPAnalyticalInversionMoveEvaluator(this, cloner);
+    }
+
+    public static double EvaluateMove(Permutation tour, InversionMove move, Func<int, int, double> distance, DoubleArray probabilities) {
+      var afterMove = (Permutation)tour.Clone();
+      InversionManipulator.Apply(afterMove, move.Index1, move.Index2);
+      return AnalyticalProbabilisticTravelingSalesmanProblem.Evaluate(afterMove, distance, probabilities);
+    }
+
+    protected override double EvaluateMove(Permutation tour, Func<int, int, double> distance, DoubleArray probabilities) {
+      return EvaluateMove(tour, InversionMoveParameter.ActualValue, distance, probabilities);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoOpt/PTSPEstimatedInversionMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoOpt/PTSPEstimatedInversionMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoOpt/PTSPEstimatedInversionMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,102 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("PTSP Estimated Inversion Move Evaluator", "Evaluates an inversion move (2-opt) over several realizations of tours by summing up the length of all added edges and subtracting the length of all deleted edges.")]
+  [StorableClass]
+  public class PTSPEstimatedInversionMoveEvaluator : EstimatedPTSPMoveEvaluator, IPermutationInversionMoveOperator {
+
+    public ILookupParameter<InversionMove> InversionMoveParameter {
+      get { return (ILookupParameter<InversionMove>)Parameters["InversionMove"]; }
+    }
+
+    [StorableConstructor]
+    protected PTSPEstimatedInversionMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected PTSPEstimatedInversionMoveEvaluator(PTSPEstimatedInversionMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public PTSPEstimatedInversionMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<InversionMove>("InversionMove", "The move to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPEstimatedInversionMoveEvaluator(this, cloner);
+    }
+
+    public static double EvaluateMove(Permutation tour, InversionMove move, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
+      double moveQuality = 0;
+      var edges = new int[4];
+      var indices = new int[4];
+      edges[0] = tour.GetCircular(move.Index1 - 1);
+      indices[0] = move.Index1 - 1;
+      if (indices[0] == -1) indices[0] = tour.Length - 1;
+      edges[1] = tour[move.Index1];
+      indices[1] = move.Index1;
+      edges[2] = tour[move.Index2];
+      indices[2] = move.Index2;
+      edges[3] = tour.GetCircular(move.Index2 + 1);
+      indices[3] = move.Index2 + 1;
+      if (indices[3] == tour.Length + 1) indices[3] = 0;
+      var aPosteriori = new int[4];
+      foreach (var realization in realizations) {
+        for (var i = 0; i < edges.Length; i++) {
+          if (realization[edges[i]]) {
+            aPosteriori[i] = edges[i];
+          } else {
+            var j = 1;
+            if (i % 2 == 0) {
+              // find nearest predecessor in realization if source edge
+              while (!realization[tour.GetCircular(indices[i] - j)]) {
+                j++;
+              }
+              aPosteriori[i] = tour.GetCircular(indices[i] - j);
+            } else {
+              // find nearest successor in realization if target edge
+              while (!realization[tour.GetCircular(indices[i] + j)]) {
+                j++;
+              }
+              aPosteriori[i] = tour.GetCircular(indices[i] + j);
+            }
+          }
+        }
+        // compute cost difference between the two a posteriori solutions
+        if (!(aPosteriori[0] == aPosteriori[2] && aPosteriori[1] == aPosteriori[3])) {
+          moveQuality = moveQuality + distance(aPosteriori[0], aPosteriori[2]) + distance(aPosteriori[1], aPosteriori[3])
+            - distance(aPosteriori[0], aPosteriori[1]) - distance(aPosteriori[2], aPosteriori[3]);
+        }
+        Array.Clear(aPosteriori, 0, aPosteriori.Length);
+      }
+      // return average of cost differences
+      return moveQuality / realizations.Count;
+    }
+
+    protected override double EvaluateMove(Permutation tour, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
+      return EvaluateMove(tour, InversionMoveParameter.ActualValue, distance, realizations);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/ExhaustiveTwoPointFiveMoveGenerator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/ExhaustiveTwoPointFiveMoveGenerator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/ExhaustiveTwoPointFiveMoveGenerator.cs	(revision 13484)
@@ -0,0 +1,80 @@
+﻿#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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Exhaustive 2.5-MoveGenerator", "Generates all possible inversion and shift moves (2.5-opt) from a given permutation.")]
+  [StorableClass]
+  public sealed class ExhaustiveTwoPointFiveMoveGenerator : TwoPointFiveMoveGenerator, IExhaustiveMoveGenerator {
+
+    [StorableConstructor]
+    private ExhaustiveTwoPointFiveMoveGenerator(bool deserializing) : base(deserializing) { }
+    private ExhaustiveTwoPointFiveMoveGenerator(ExhaustiveTwoPointFiveMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveTwoPointFiveMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveTwoPointFiveMoveGenerator(this, cloner);
+    }
+
+    public static TwoPointFiveMove[] Apply(Permutation permutation) {
+      return Generate(permutation).ToArray();
+    }
+
+    public static IEnumerable<TwoPointFiveMove> Generate(Permutation permutation) {
+      int length = permutation.Length;
+      if (length == 1) throw new ArgumentException("Exhaustive 2.5-MoveGenerator: There cannot be a 2.5 move given a permutation of length 1.", "permutation");
+      int totalMoves = (length) * (length - 1) / 2;
+
+      if (permutation.PermutationType == PermutationTypes.RelativeUndirected) {
+        if (totalMoves - 3 > 0) {
+          for (int i = 0; i < length - 1; i++) {
+            for (int j = i + 1; j < length; j++) {
+              // doesn't make sense to inverse the whole permutation or the whole but one in case of relative undirected permutations
+              if (j - i >= length - 2) continue;
+              yield return new TwoPointFiveMove(i, j, true);
+              yield return new TwoPointFiveMove(i, j, false);
+            }
+          }
+        } else { // when length is 3 or less, there's actually no difference, but for the sake of not crashing the algorithm create a dummy move
+          yield return new TwoPointFiveMove(0, 1, true);
+        }
+      } else {
+        for (int i = 0; i < length - 1; i++)
+          for (int j = i + 1; j < length; j++) {
+            yield return new TwoPointFiveMove(i, j, true);
+            yield return new TwoPointFiveMove(i, j, false);
+          }
+      }
+    }
+
+    protected override TwoPointFiveMove[] GenerateMoves(Permutation permutation) {
+      return Apply(permutation);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/PTSPAnalyticalTwoPointFiveMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/PTSPAnalyticalTwoPointFiveMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/PTSPAnalyticalTwoPointFiveMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,65 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("PTSP Analytical 2.5-MoveEvaluator", "Operator that evaluates 2.5-p-opt moves of PTSP by a full solution evaluation.")]
+  [StorableClass]
+  public class PTSPAnalyticalTwoPointFiveMoveEvaluator : AnalyticalPTSPMoveEvaluator, ITwoPointFiveMoveOperator {
+
+    public ILookupParameter<TwoPointFiveMove> TwoPointFiveMoveParameter {
+      get { return (ILookupParameter<TwoPointFiveMove>)Parameters["TwoPointFiveMove"]; }
+    }
+
+    [StorableConstructor]
+    protected PTSPAnalyticalTwoPointFiveMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected PTSPAnalyticalTwoPointFiveMoveEvaluator(PTSPAnalyticalTwoPointFiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public PTSPAnalyticalTwoPointFiveMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<TwoPointFiveMove>("TwoPointFiveMove", "The move to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPAnalyticalTwoPointFiveMoveEvaluator(this, cloner);
+    }
+
+    protected override double EvaluateMove(Permutation permutation, Func<int, int, double> distance, DoubleArray probabilities) {
+      return EvaluateMove(permutation, TwoPointFiveMoveParameter.ActualValue, distance, probabilities);
+    }
+
+    public static double EvaluateMove(Permutation permutation, TwoPointFiveMove move, Func<int, int, double> distance, DoubleArray probabilities) {
+      if (move.IsInvert) {
+        return PTSPAnalyticalInversionMoveEvaluator.EvaluateMove(permutation,
+          new InversionMove(move.Index1, move.Index2, move.Permutation), distance, probabilities);
+      } else {
+        return PTSPAnalyticalInsertionMoveEvaluator.EvaluateMove(permutation,
+          new TranslocationMove(move.Index1, move.Index1, move.Index2), distance, probabilities);
+      }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/PTSPEstimatedTwoPointFiveMoveEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/PTSPEstimatedTwoPointFiveMoveEvaluator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/PTSPEstimatedTwoPointFiveMoveEvaluator.cs	(revision 13484)
@@ -0,0 +1,65 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("PTSP Estimated 2.5-MoveEvaluator", "Operator that evaluates 2.5-p-opt moves of PTSP")]
+  [StorableClass]
+  public class PTSPEstimatedTwoPointFiveMoveEvaluator : EstimatedPTSPMoveEvaluator, ITwoPointFiveMoveOperator {
+
+    public ILookupParameter<TwoPointFiveMove> TwoPointFiveMoveParameter {
+      get { return (ILookupParameter<TwoPointFiveMove>)Parameters["TwoPointFiveMove"]; }
+    }
+
+    [StorableConstructor]
+    protected PTSPEstimatedTwoPointFiveMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected PTSPEstimatedTwoPointFiveMoveEvaluator(PTSPEstimatedTwoPointFiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public PTSPEstimatedTwoPointFiveMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<TwoPointFiveMove>("TwoPointFiveMove", "The move to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPEstimatedTwoPointFiveMoveEvaluator(this, cloner);
+    }
+
+    protected override double EvaluateMove(Permutation permutation, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
+      return EvaluateMove(permutation, TwoPointFiveMoveParameter.ActualValue, distance, realizations);
+    }
+
+    public static double EvaluateMove(Permutation permutation, TwoPointFiveMove move, Func<int, int, double> distance, ItemList<BoolArray> realizations) {
+      if (move.IsInvert) {
+        return PTSPEstimatedInversionMoveEvaluator.EvaluateMove(permutation,
+          new InversionMove(move.Index1, move.Index2, move.Permutation), distance, realizations);
+      } else {
+        return PTSPEstimatedInsertionMoveEvaluator.EvaluateMove(permutation,
+          new TranslocationMove(move.Index1, move.Index1, move.Index2), distance, realizations);
+      }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/StochasticTwoPointFiveMultiMoveGenerator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/StochasticTwoPointFiveMultiMoveGenerator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/StochasticTwoPointFiveMultiMoveGenerator.cs	(revision 13484)
@@ -0,0 +1,71 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Stochastic 2.5-MultiMoveGenerator", "Randomly samples n from all possible inversion and shift moves (2.5-opt) from a given permutation.")]
+  [StorableClass]
+  public sealed class StochasticTwoPointFiveMultiMoveGenerator : TwoPointFiveMoveGenerator, IMultiMoveGenerator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public IntValue SampleSize {
+      get { return SampleSizeParameter.Value; }
+      set { SampleSizeParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    private StochasticTwoPointFiveMultiMoveGenerator(bool deserializing) : base(deserializing) { }
+    private StochasticTwoPointFiveMultiMoveGenerator(StochasticTwoPointFiveMultiMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticTwoPointFiveMultiMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticTwoPointFiveMultiMoveGenerator(this, cloner);
+    }
+
+    public static TwoPointFiveMove[] Apply(Permutation permutation, IRandom random, int sampleSize) {
+      var moves = new TwoPointFiveMove[sampleSize];
+      for (var i = 0; i < sampleSize; i++) {
+        moves[i] = StochasticTwoPointFiveSingleMoveGenerator.Apply(permutation, random);
+      }
+      return moves;
+    }
+
+    protected override TwoPointFiveMove[] GenerateMoves(Permutation permutation) {
+      return Apply(permutation, RandomParameter.ActualValue, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/StochasticTwoPointFiveSingleMoveGenerator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/StochasticTwoPointFiveSingleMoveGenerator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/StochasticTwoPointFiveSingleMoveGenerator.cs	(revision 13484)
@@ -0,0 +1,70 @@
+﻿#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.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Stochastic 2.5-SingleMoveGenerator", "Randomly samples a single from all possible inversion and shift moves (2.5-opt) from a given permutation.")]
+  [StorableClass]
+  public sealed class StochasticTwoPointFiveSingleMoveGenerator : TwoPointFiveMoveGenerator, IStochasticOperator, ISingleMoveGenerator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    private StochasticTwoPointFiveSingleMoveGenerator(bool deserializing) : base(deserializing) { }
+    private StochasticTwoPointFiveSingleMoveGenerator(StochasticTwoPointFiveSingleMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticTwoPointFiveSingleMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticTwoPointFiveSingleMoveGenerator(this, cloner);
+    }
+
+    public static TwoPointFiveMove Apply(Permutation permutation, IRandom random) {
+      int length = permutation.Length;
+      if (length == 1) throw new ArgumentException("Stochastic 2.5-SingleMoveGenerator: There cannot be an inversion move given a permutation of length 1.", "permutation");
+      int index1 = random.Next(length - 1);
+      int index2 = random.Next(index1 + 1, length);
+      if (permutation.PermutationType == PermutationTypes.RelativeUndirected) {
+        if (length > 3) {
+          while (index2 - index1 >= length - 2)
+            index2 = random.Next(index1 + 1, length);
+        }
+      }
+      bool isInvert = random.NextDouble() > 0.5;
+      return new TwoPointFiveMove(index1, index2, isInvert);
+
+    }
+
+    protected override TwoPointFiveMove[] GenerateMoves(Permutation permutation) {
+      return new[] { Apply(permutation, RandomParameter.ActualValue) };
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMove.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMove.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMove.cs	(revision 13484)
@@ -0,0 +1,70 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("2.5-Move", "Represents a 2.5-move.")]
+  [StorableClass]
+  public sealed class TwoPointFiveMove : Item {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+    [Storable]
+    public Permutation Permutation { get; protected set; }
+    [Storable]
+    public bool IsInvert { get; protected set; }
+
+    [StorableConstructor]
+    public TwoPointFiveMove() : this(-1, -1, null, true) { }
+    private TwoPointFiveMove(bool deserializing) : base(deserializing) { }
+    private TwoPointFiveMove(TwoPointFiveMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+      this.IsInvert = original.IsInvert;
+      this.Permutation = cloner.Clone(original.Permutation);
+    }
+    public TwoPointFiveMove(int index1, int index2, Permutation permutation, bool isinvert)
+      : base() {
+      Index1 = index1;
+      Index2 = index2;
+      IsInvert = isinvert;
+      Permutation = permutation;
+    }
+
+    public TwoPointFiveMove(int index1, int index2, bool isinvert)
+      : base() {
+      Index1 = index1;
+      Index2 = index2;
+      IsInvert = isinvert;
+      Permutation = null;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TwoPointFiveMove(this, cloner);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMoveGenerator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMoveGenerator.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMoveGenerator.cs	(revision 13484)
@@ -0,0 +1,70 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("TwoPointFiveMoveGenerator", "Base class for all inversion and shift (2.5-opt) move generators.")]
+  [StorableClass]
+  public abstract class TwoPointFiveMoveGenerator : SingleSuccessorOperator, ITwoPointFiveMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
+    }
+    public ILookupParameter<TwoPointFiveMove> TwoPointFiveMoveParameter {
+      get { return (LookupParameter<TwoPointFiveMove>)Parameters["TwoPointFiveMove"]; }
+    }
+
+    [StorableConstructor]
+    protected TwoPointFiveMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected TwoPointFiveMoveGenerator(TwoPointFiveMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    protected TwoPointFiveMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The permutation for which moves should be generated."));
+      Parameters.Add(new LookupParameter<TwoPointFiveMove>("TwoPointFiveMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    public override IOperation Apply() {
+      var p = PermutationParameter.ActualValue;
+      var moves = GenerateMoves(p);
+      var moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(TwoPointFiveMoveParameter.ActualName, moves[i]));
+      }
+      ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract TwoPointFiveMove[] GenerateMoves(Permutation permutation);
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMoveMaker.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMoveMaker.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Moves/TwoPointFiveOpt/TwoPointFiveMoveMaker.cs	(revision 13484)
@@ -0,0 +1,88 @@
+﻿#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 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;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("TwoPointFiveMoveMaker", "Peforms an inversion and shift (2.5-opt) on a given permutation and updates the quality.")]
+  [StorableClass]
+  public class TwoPointFiveMoveMaker : SingleSuccessorOperator, ITwoPointFiveMoveOperator, IMoveMaker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<TwoPointFiveMove> TwoPointFiveMoveParameter {
+      get { return (ILookupParameter<TwoPointFiveMove>)Parameters["TwoPointFiveMove"]; }
+    }
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
+    }
+
+    [StorableConstructor]
+    protected TwoPointFiveMoveMaker(bool deserializing) : base(deserializing) { }
+    protected TwoPointFiveMoveMaker(TwoPointFiveMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public TwoPointFiveMoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<TwoPointFiveMove>("TwoPointFiveMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TwoPointFiveMoveMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var move = TwoPointFiveMoveParameter.ActualValue;
+      var permutation = PermutationParameter.ActualValue;
+      var moveQuality = MoveQualityParameter.ActualValue;
+      var quality = QualityParameter.ActualValue;
+
+      Apply(permutation, move);
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+
+    public static void Apply(Permutation permutation, TwoPointFiveMove move) {
+      if (move.IsInvert) {
+        InversionManipulator.Apply(permutation, move.Index1, move.Index2);
+      } else {
+        TranslocationManipulator.Apply(permutation, move.Index1, move.Index1, move.Index2);
+      }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/PTSP.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/PTSP.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/PTSP.cs	(revision 13484)
@@ -0,0 +1,239 @@
+﻿#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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Item("Probabilistic Traveling Salesman Problem (PTSP)", "Represents a Probabilistic Traveling Salesman Problem.")]
+  [StorableClass]
+  public abstract class ProbabilisticTravelingSalesmanProblem : SingleObjectiveBasicProblem<PermutationEncoding>,
+  IProblemInstanceConsumer<PTSPData> {
+    protected bool SuppressEvents { get; set; }
+
+    private static readonly int DistanceMatrixSizeLimit = 1000;
+
+    #region Parameter Properties
+    public OptionalValueParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (OptionalValueParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    }
+    public OptionalValueParameter<DistanceCalculator> DistanceCalculatorParameter {
+      get { return (OptionalValueParameter<DistanceCalculator>)Parameters["DistanceCalculator"]; }
+    }
+    public OptionalValueParameter<DistanceMatrix> DistanceMatrixParameter {
+      get { return (OptionalValueParameter<DistanceMatrix>)Parameters["DistanceMatrix"]; }
+    }
+    public IFixedValueParameter<BoolValue> UseDistanceMatrixParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
+    }
+    public OptionalValueParameter<Permutation> BestKnownSolutionParameter {
+      get { return (OptionalValueParameter<Permutation>)Parameters["BestKnownSolution"]; }
+    }
+    public IValueParameter<DoubleArray> ProbabilitiesParameter {
+      get { return (IValueParameter<DoubleArray>)Parameters["Probabilities"]; }
+    }
+    #endregion
+
+    #region Properties
+    public DoubleMatrix Coordinates {
+      get { return CoordinatesParameter.Value; }
+      set { CoordinatesParameter.Value = value; }
+    }
+    public DistanceCalculator DistanceCalculator {
+      get { return DistanceCalculatorParameter.Value; }
+      set { DistanceCalculatorParameter.Value = value; }
+    }
+    public DistanceMatrix DistanceMatrix {
+      get { return DistanceMatrixParameter.Value; }
+      set { DistanceMatrixParameter.Value = value; }
+    }
+    public bool UseDistanceMatrix {
+      get { return UseDistanceMatrixParameter.Value.Value; }
+      set { UseDistanceMatrixParameter.Value.Value = value; }
+    }
+    public Permutation BestKnownSolution {
+      get { return BestKnownSolutionParameter.Value; }
+      set { BestKnownSolutionParameter.Value = value; }
+    }
+    public DoubleArray Probabilities {
+      get { return ProbabilitiesParameter.Value; }
+      set { ProbabilitiesParameter.Value = value; }
+    }
+
+    #endregion
+
+    public override bool Maximization {
+      get { return false; }
+    }
+
+    [StorableConstructor]
+    protected ProbabilisticTravelingSalesmanProblem(bool deserializing) : base(deserializing) { }
+    protected ProbabilisticTravelingSalesmanProblem(ProbabilisticTravelingSalesmanProblem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
+    protected ProbabilisticTravelingSalesmanProblem() {
+      Parameters.Add(new OptionalValueParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the cities."));
+      Parameters.Add(new OptionalValueParameter<DistanceCalculator>("DistanceCalculator", "Calculates the distance between two rows in the coordinates matrix."));
+      Parameters.Add(new OptionalValueParameter<DistanceMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
+      Parameters.Add(new FixedValueParameter<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 ValueParameter<DoubleArray>("Probabilities", "This list describes for each city the probability of appearing in a realized instance."));
+
+      var 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 }
+      });
+      Coordinates = coordinates;
+      Encoding.Length = coordinates.Rows;
+      DistanceCalculator = new EuclideanDistance();
+      DistanceMatrix = new DistanceMatrix(CalculateDistances());
+      Probabilities = new DoubleArray(Enumerable.Range(0, coordinates.Rows).Select(x => 0.5).ToArray());
+
+      RegisterEventHandlers();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    private void RegisterEventHandlers() {
+      CoordinatesParameter.ValueChanged += CoordinatesParameterOnValueChanged;
+      if (Coordinates != null) {
+        Coordinates.RowsChanged += CoordinatesOnChanged;
+        Coordinates.ItemChanged += CoordinatesOnChanged;
+      }
+      UseDistanceMatrixParameter.Value.ValueChanged += UseDistanceMatrixValueChanged;
+      DistanceCalculatorParameter.ValueChanged += DistanceCalculatorParameterOnValueChanged;
+    }
+
+    private void CoordinatesParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      if (Coordinates != null) {
+        Coordinates.RowsChanged += CoordinatesOnChanged;
+        Coordinates.ItemChanged += CoordinatesOnChanged;
+      }
+      if (SuppressEvents) return;
+      UpdateInstance();
+    }
+
+    private void CoordinatesOnChanged(object sender, EventArgs eventArgs) {
+      if (SuppressEvents) return;
+      UpdateInstance();
+    }
+
+    private void UseDistanceMatrixValueChanged(object sender, EventArgs eventArgs) {
+      if (SuppressEvents) return;
+      UpdateInstance();
+    }
+
+    private void DistanceCalculatorParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      if (SuppressEvents) return;
+      UpdateInstance();
+    }
+
+    public override double Evaluate(Individual individual, IRandom random) {
+      return Evaluate(individual.Permutation(), random);
+    }
+
+    public abstract double Evaluate(Permutation tour, IRandom random);
+
+    public double[,] CalculateDistances() {
+      var coords = Coordinates;
+      var len = coords.Rows;
+      var dist = DistanceCalculator;
+
+      var matrix = new double[len, len];
+      for (var i = 0; i < len - 1; i++)
+        for (var j = i + 1; j < len; j++)
+          matrix[i, j] = matrix[j, i] = dist.Calculate(i, j, coords);
+
+      return matrix;
+    }
+
+    public virtual void Load(PTSPData data) {
+      try {
+        SuppressEvents = true;
+        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.Coordinates == null || data.Coordinates.GetLength(0) != data.Dimension || data.Coordinates.GetLength(1) != 2))
+          throw new System.IO.InvalidDataException("The given instance is too large for using a distance matrix and there is a problem with the coordinates.");
+        if (data.Coordinates != null && (data.Coordinates.GetLength(0) != data.Dimension || 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 respectively.");
+
+        switch (data.DistanceMeasure) {
+          case DistanceMeasure.Direct:
+            DistanceCalculator = null;
+            if (data.Dimension > DistanceMatrixSizeLimit && Coordinates != null) {
+              DistanceCalculator = new EuclideanDistance();
+              UseDistanceMatrix = false;
+            } else UseDistanceMatrix = true;
+            break;
+          case DistanceMeasure.Att: DistanceCalculator = new AttDistance(); break;
+          case DistanceMeasure.Euclidean: DistanceCalculator = new EuclideanDistance(); break;
+          case DistanceMeasure.Geo: DistanceCalculator = new GeoDistance(); break;
+          case DistanceMeasure.Manhattan: DistanceCalculator = new ManhattanDistance(); break;
+          case DistanceMeasure.Maximum: DistanceCalculator = new MaximumDistance(); break;
+          case DistanceMeasure.RoundedEuclidean: DistanceCalculator = new RoundedEuclideanDistance(); break;
+          case DistanceMeasure.UpperEuclidean: DistanceCalculator = new UpperEuclideanDistance(); break;
+          default: throw new ArgumentException("Distance measure is unknown");
+        }
+
+        Name = data.Name;
+        Description = data.Description;
+
+        Probabilities = new DoubleArray(data.Probabilities);
+        BestKnownSolution = data.BestKnownTour != null ? new Permutation(PermutationTypes.RelativeUndirected, data.BestKnownTour) : null;
+        Coordinates = data.Coordinates != null && data.Coordinates.GetLength(0) > 0 ? new DoubleMatrix(data.Coordinates) : null;
+        DistanceMatrix = data.Dimension <= DistanceMatrixSizeLimit && UseDistanceMatrix ? new DistanceMatrix(data.GetDistanceMatrix()) : null;
+
+        Encoding.Length = data.Dimension;
+      } finally { SuppressEvents = false; }
+      OnReset();
+    }
+
+    private void UpdateInstance() {
+      var len = GetProblemDimension();
+      if (Coordinates != null && Coordinates.Rows <= DistanceMatrixSizeLimit
+        && DistanceCalculator != null && UseDistanceMatrix)
+        DistanceMatrix = new DistanceMatrix(CalculateDistances());
+      if (!UseDistanceMatrix) DistanceMatrix = null;
+      Encoding.Length = len;
+
+      OnReset();
+    }
+
+    private int GetProblemDimension() {
+      if (Coordinates == null && DistanceMatrix == null) throw new InvalidOperationException("Both coordinates and distance matrix are null, please specify at least one of them.");
+      return Coordinates != null ? Coordinates.Rows : DistanceMatrix.Rows;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/PathPTSPTour.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/PathPTSPTour.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/PathPTSPTour.cs	(revision 13484)
@@ -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("PathPTSPTour", "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: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Plugin.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Plugin.cs.frame	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Plugin.cs.frame	(revision 13484)
@@ -0,0 +1,41 @@
+﻿#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 HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.PTSP {
+  [Plugin("HeuristicLab.Problems.PTSP", "Provides an implementation of the probabilistic traveling salesman problem (PTSP)", "3.3.13.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.PTSP-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.PermutationEncoding", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  public class HeuristicLabProblemsPTSPPlugin : PluginBase {
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Properties/AssemblyInfo.cs.frame	(revision 13484)
+++ /trunk/sources/HeuristicLab.Problems.PTSP/3.3/Properties/AssemblyInfo.cs.frame	(revision 13484)
@@ -0,0 +1,36 @@
+﻿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.Problems.PTSP")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2015 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("f26124c8-f9ae-4c86-9c42-d4a1898df780")]
+
+// 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 Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.13.$WCREV$")]
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab-3.3/DeepCloneableCloningTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab-3.3/DeepCloneableCloningTest.cs	(revision 13483)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab-3.3/DeepCloneableCloningTest.cs	(revision 13484)
@@ -46,5 +46,6 @@
         typeof (HeuristicLab.Problems.DataAnalysis.ClassificationEnsembleSolution),
         typeof (HeuristicLab.Problems.DataAnalysis.RegressionEnsembleSolution),
-        typeof (HeuristicLab.Problems.Orienteering.DistanceMatrix)
+        typeof (HeuristicLab.Problems.Orienteering.DistanceMatrix),
+        typeof (HeuristicLab.Problems.PTSP.DistanceMatrix)
       };
       excludedTypes.Add(typeof(SymbolicExpressionGrammar).Assembly.GetType("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.EmptySymbolicExpressionTreeGrammar"));
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.PTSP-3.3/PTSPMoveEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.PTSP-3.3/PTSPMoveEvaluatorTest.cs	(revision 13484)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.PTSP-3.3/PTSPMoveEvaluatorTest.cs	(revision 13484)
@@ -0,0 +1,128 @@
+﻿#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.Random;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace HeuristicLab.Problems.PTSP.Tests {
+  /// <summary>
+  ///This is a test class for PTSP move evaluators
+  ///</summary>
+  [TestClass()]
+  public class PTSPMoveEvaluatorTest {
+    private const int ProblemSize = 10;
+    private const int RealizationsSize = 100;
+    private static DoubleMatrix coordinates;
+    private static DistanceMatrix distances;
+    private static Permutation tour;
+    private static MersenneTwister random;
+    private static ItemList<BoolArray> realizations;
+    private static DoubleArray probabilities;
+
+    [ClassInitialize]
+    public static void MyClassInitialize(TestContext testContext) {
+      random = new MersenneTwister();
+      coordinates = new DoubleMatrix(ProblemSize, 2);
+      distances = new DistanceMatrix(ProblemSize, ProblemSize);
+      for (var i = 0; i < ProblemSize; i++) {
+        coordinates[i, 0] = random.Next(ProblemSize * 10);
+        coordinates[i, 1] = random.Next(ProblemSize * 10);
+      }
+      for (var i = 0; i < ProblemSize - 1; i++) {
+        for (var j = i + 1; j < ProblemSize; j++) {
+          distances[i, j] = Math.Round(Math.Sqrt(Math.Pow(coordinates[i, 0] - coordinates[j, 0], 2) + Math.Pow(coordinates[i, 1] - coordinates[j, 1], 2)));
+          distances[j, i] = distances[i, j];
+        }
+      }
+
+      probabilities = new DoubleArray(ProblemSize);
+      for (var i = 0; i < ProblemSize; i++) {
+        probabilities[i] = random.NextDouble();
+      }
+
+      realizations = new ItemList<BoolArray>(RealizationsSize);
+      for (var i = 0; i < RealizationsSize; i++) {
+        var countOnes = 0;
+        var newRealization = new BoolArray(ProblemSize);
+        while (countOnes < 4) { //only generate realizations with at least 4 cities visited
+          countOnes = 0;
+          for (var j = 0; j < ProblemSize; j++) {
+            newRealization[j] = random.NextDouble() < probabilities[j];
+            if (newRealization[j]) countOnes++;
+          }
+        }
+        realizations.Add(newRealization);
+      }
+
+      tour = new Permutation(PermutationTypes.RelativeUndirected, ProblemSize, random);
+    }
+
+    [TestMethod]
+    [TestCategory("Problems.ProbabilisticTravelingSalesman")]
+    [TestProperty("Time", "short")]
+    public void InversionMoveEvaluatorTest() {
+      Func<int, int, double> distance = (a, b) => distances[a, b];
+      double variance;
+      var beforeMatrix = EstimatedProbabilisticTravelingSalesmanProblem.Evaluate(tour, distance, realizations, out variance);
+
+      for (var i = 0; i < 500; i++) {
+        var move = StochasticInversionSingleMoveGenerator.Apply(tour, random);
+        var moveMatrix = PTSPEstimatedInversionMoveEvaluator.EvaluateMove(tour, move, distance, realizations);
+        InversionManipulator.Apply(tour, move.Index1, move.Index2);
+        var afterMatrix = EstimatedProbabilisticTravelingSalesmanProblem.Evaluate(tour, distance, realizations, out variance);
+
+        Assert.IsTrue(Math.Abs(moveMatrix).IsAlmost(Math.Abs(afterMatrix - beforeMatrix)),
+          string.Format(@"Inversion move is calculated with quality {0}, but actual difference is {4}.
+The move would invert the tour {1} between values {2} and {3}.",
+          moveMatrix, tour, tour[move.Index1], tour[move.Index2], Math.Abs(afterMatrix - beforeMatrix)));
+
+        beforeMatrix = afterMatrix;
+      }
+    }
+
+    [TestMethod]
+    [TestCategory("Problems.ProbabilisticTravelingSalesman")]
+    [TestProperty("Time", "short")]
+    public void InsertionMoveEvaluatorTest() {
+      Func<int, int, double> distance = (a, b) => distances[a, b];
+      double variance;
+      var beforeMatrix = EstimatedProbabilisticTravelingSalesmanProblem.Evaluate(tour, distance, realizations, out variance);
+      for (var i = 0; i < 500; i++) {
+        var move = StochasticTranslocationSingleMoveGenerator.Apply(tour, random);
+        var moveMatrix = PTSPEstimatedInsertionMoveEvaluator.EvaluateMove(tour, move, distance, realizations);
+        TranslocationManipulator.Apply(tour, move.Index1, move.Index1, move.Index3);
+        var afterMatrix = EstimatedProbabilisticTravelingSalesmanProblem.Evaluate(tour, distance, realizations, out variance);
+
+        Assert.IsTrue(Math.Abs(moveMatrix).IsAlmost(Math.Abs(afterMatrix - beforeMatrix)),
+          string.Format(@"Insertion move is calculated with quality {0}, but actual difference is {4}.
+The move would invert the tour {1} between values {2} and {3}.",
+          moveMatrix, tour, tour[move.Index1], tour[move.Index2], Math.Abs(afterMatrix - beforeMatrix)));
+
+        beforeMatrix = afterMatrix;
+      }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 13483)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 13484)
@@ -201,4 +201,5 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\bin\HeuristicLab.Encodings.LinearLinkageEncoding-3.3.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="HeuristicLab.Encodings.PermutationEncoding-3.3">
@@ -367,4 +368,9 @@
     <Reference Include="HeuristicLab.Problems.Orienteering-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <HintPath>..\bin\HeuristicLab.Problems.Orienteering-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.PTSP-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\bin\HeuristicLab.Problems.PTSP-3.3.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -572,4 +578,5 @@
     <Compile Include="HeuristicLab.Problems.Instances-3.3\TSPLIBInstanceProviderTest.cs" />
     <Compile Include="HeuristicLab.Problems.Instances.DataAnalysis-3.3\ClassificationInstanceProviderTest.cs" />
+    <Compile Include="HeuristicLab.Problems.PTSP-3.3\PTSPMoveEvaluatorTest.cs" />
     <Compile Include="HeuristicLab.Problems.QuadraticAssignment-3.3\QAPLIBInstancesTest.cs" />
     <Compile Include="HeuristicLab.Problems.QuadraticAssignment-3.3\QAPMoveEvaluatorTest.cs" />
