Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj	(revision 14406)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj	(revision 14406)
@@ -0,0 +1,229 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{96E5ED5B-187D-4012-9CDA-D85CDAD38342}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.SimulatedAnnealing</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.SimulatedAnnealing-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Plugin.cs" />
+    <Compile Include="SimulatedAnnealingImprovementOperator.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SimulatedAnnealing.cs" />
+    <Compile Include="SimulatedAnnealingMainLoop.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">
+      <Project>{887425B4-4348-49ED-A457-B7D2C26DDBF9}</Project>
+      <Name>HeuristicLab.Analysis-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <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\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.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.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
+      <Project>{25087811-F74C-4128-BC86-8324271DA13E}</Project>
+      <Name>HeuristicLab.Optimization.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.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>
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
+</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Plugin.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Plugin.cs	(revision 14406)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Plugin.cs	(revision 14406)
@@ -0,0 +1,43 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Algorithms.SimulatedAnnealing plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Algorithms.SimulatedAnnealing", "3.3.14.14195")]
+  [PluginFile("HeuristicLab.Algorithms.SimulatedAnnealing-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  public class HeuristicLabAlgorithmsSimulatedAnnealingPlugin : PluginBase {
+  }
+}
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Plugin.cs.frame
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Plugin.cs.frame	(revision 14406)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Plugin.cs.frame	(revision 14406)
@@ -0,0 +1,43 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Algorithms.SimulatedAnnealing plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Algorithms.SimulatedAnnealing", "3.3.14.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.SimulatedAnnealing-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  public class HeuristicLabAlgorithmsSimulatedAnnealingPlugin : PluginBase {
+  }
+}
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Properties/AssemblyInfo.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Properties/AssemblyInfo.cs	(revision 14406)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Properties/AssemblyInfo.cs	(revision 14406)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Reflection;
+using System.Runtime.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.Algorithms.SimulatedAnnealing")]
+[assembly: AssemblyDescription("HeuristicLab simulated annealing (SA)")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2016 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("0c41579a-d3c4-49fb-af7a-119eea1155ac")]
+
+// 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("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.14.14195")]
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Properties/AssemblyInfo.cs.frame	(revision 14406)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/Properties/AssemblyInfo.cs.frame	(revision 14406)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Reflection;
+using System.Runtime.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.Algorithms.SimulatedAnnealing")]
+[assembly: AssemblyDescription("HeuristicLab simulated annealing (SA)")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2016 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("0c41579a-d3c4-49fb-af7a-119eea1155ac")]
+
+// 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("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.14.$WCREV$")]
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs	(revision 14406)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs	(revision 14406)
@@ -0,0 +1,500 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing {
+  [Item("Simulated Annealing (SA)", "A simulated annealing algorithm.")]
+  [Creatable(CreatableAttribute.Categories.SingleSolutionAlgorithms, Priority = 140)]
+  [StorableClass]
+  public sealed class SimulatedAnnealing : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+    public string Filename { get; set; }
+
+    #region Problem Properties
+    public override Type ProblemType {
+      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
+    }
+    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
+      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
+      set { base.Problem = value; }
+    }
+    #endregion
+
+    #region Parameter Properties
+    private ValueParameter<IntValue> SeedParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
+    }
+    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
+    }
+    public IConstrainedValueParameter<IMultiMoveGenerator> MoveGeneratorParameter {
+      get { return (IConstrainedValueParameter<IMultiMoveGenerator>)Parameters["MoveGenerator"]; }
+    }
+    public IConstrainedValueParameter<IMoveMaker> MoveMakerParameter {
+      get { return (IConstrainedValueParameter<IMoveMaker>)Parameters["MoveMaker"]; }
+    }
+    public IConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter {
+      get { return (IConstrainedValueParameter<ISingleObjectiveMoveEvaluator>)Parameters["MoveEvaluator"]; }
+    }
+    public IConstrainedValueParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter {
+      get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["AnnealingOperator"]; }
+    }
+    private ValueParameter<IntValue> MaximumIterationsParameter {
+      get { return (ValueParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+    private ValueParameter<IntValue> InnerIterationsParameter {
+      get { return (ValueParameter<IntValue>)Parameters["InnerIterations"]; }
+    }
+    private ValueParameter<DoubleValue> StartTemperatureParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["StartTemperature"]; }
+    }
+    private ValueParameter<DoubleValue> EndTemperatureParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["EndTemperature"]; }
+    }
+    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
+      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
+    }
+    #endregion
+
+    #region Properties
+    public IntValue Seed {
+      get { return SeedParameter.Value; }
+      set { SeedParameter.Value = value; }
+    }
+    public BoolValue SetSeedRandomly {
+      get { return SetSeedRandomlyParameter.Value; }
+      set { SetSeedRandomlyParameter.Value = value; }
+    }
+    public IMultiMoveGenerator MoveGenerator {
+      get { return MoveGeneratorParameter.Value; }
+      set { MoveGeneratorParameter.Value = value; }
+    }
+    public IMoveMaker MoveMaker {
+      get { return MoveMakerParameter.Value; }
+      set { MoveMakerParameter.Value = value; }
+    }
+    public ISingleObjectiveMoveEvaluator MoveEvaluator {
+      get { return MoveEvaluatorParameter.Value; }
+      set { MoveEvaluatorParameter.Value = value; }
+    }
+    public IDiscreteDoubleValueModifier AnnealingOperator {
+      get { return AnnealingOperatorParameter.Value; }
+      set { AnnealingOperatorParameter.Value = value; }
+    }
+    public IntValue MaximumIterations {
+      get { return MaximumIterationsParameter.Value; }
+      set { MaximumIterationsParameter.Value = value; }
+    }
+    public IntValue InnerIterations {
+      get { return InnerIterationsParameter.Value; }
+      set { InnerIterationsParameter.Value = value; }
+    }
+    public DoubleValue StartTemperature {
+      get { return StartTemperatureParameter.Value; }
+      set { StartTemperatureParameter.Value = value; }
+    }
+    public DoubleValue EndTemperature {
+      get { return EndTemperatureParameter.Value; }
+      set { EndTemperatureParameter.Value = value; }
+    }
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+      set { AnalyzerParameter.Value = value; }
+    }
+    private RandomCreator RandomCreator {
+      get { return (RandomCreator)OperatorGraph.InitialOperator; }
+    }
+    private SolutionsCreator SolutionsCreator {
+      get { return (SolutionsCreator)RandomCreator.Successor; }
+    }
+    private SimulatedAnnealingMainLoop MainLoop {
+      get { return FindMainLoop(SolutionsCreator.Successor); }
+    }
+    [Storable]
+    private QualityAnalyzer qualityAnalyzer;
+    [Storable]
+    private SingleValueAnalyzer temperatureAnalyzer;
+    #endregion
+
+    [StorableConstructor]
+    private SimulatedAnnealing(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (temperatureAnalyzer == null) {
+        temperatureAnalyzer = new SingleValueAnalyzer();
+        temperatureAnalyzer.Name = "TemperatureAnalyzer";
+        temperatureAnalyzer.ResultsParameter.ActualName = "Results";
+        temperatureAnalyzer.ValueParameter.ActualName = "Temperature";
+        temperatureAnalyzer.ValuesParameter.ActualName = "Temperature Chart";
+        Analyzer.Operators.Add(temperatureAnalyzer);
+      }
+      Initialize();
+    }
+    private SimulatedAnnealing(SimulatedAnnealing original, Cloner cloner)
+      : base(original, cloner) {
+      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      temperatureAnalyzer = cloner.Clone(original.temperatureAnalyzer);
+      Initialize();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SimulatedAnnealing(this, cloner);
+    }
+    public SimulatedAnnealing()
+      : base() {
+      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ConstrainedValueParameter<IMultiMoveGenerator>("MoveGenerator", "The operator used to generate moves to the neighborhood of the current solution."));
+      Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>("MoveEvaluator", "The operator used to evaluate a move."));
+      Parameters.Add(new ConstrainedValueParameter<IMoveMaker>("MoveMaker", "The operator used to perform a move."));
+      Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>("AnnealingOperator", "The operator used to modify the temperature."));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<IntValue>("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again).", new IntValue(10)));
+      Parameters.Add(new ValueParameter<DoubleValue>("StartTemperature", "The initial temperature.", new DoubleValue(100)));
+      Parameters.Add(new ValueParameter<DoubleValue>("EndTemperature", "The final temperature which should be reached when iterations reaches maximum iterations.", new DoubleValue(1e-6)));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
+
+      RandomCreator randomCreator = new RandomCreator();
+      SolutionsCreator solutionsCreator = new SolutionsCreator();
+      VariableCreator variableCreator = new VariableCreator();
+      ResultsCollector resultsCollector = new ResultsCollector();
+      SimulatedAnnealingMainLoop mainLoop = new SimulatedAnnealingMainLoop();
+      OperatorGraph.InitialOperator = randomCreator;
+
+      randomCreator.RandomParameter.ActualName = "Random";
+      randomCreator.SeedParameter.ActualName = SeedParameter.Name;
+      randomCreator.SeedParameter.Value = null;
+      randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
+      randomCreator.SetSeedRandomlyParameter.Value = null;
+      randomCreator.Successor = solutionsCreator;
+
+      solutionsCreator.NumberOfSolutions = new IntValue(1);
+      solutionsCreator.Successor = variableCreator;
+
+      variableCreator.Name = "Initialize EvaluatedMoves";
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedMoves", new IntValue()));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
+      variableCreator.Successor = resultsCollector;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Moves", null, "EvaluatedMoves"));
+      resultsCollector.ResultsParameter.ActualName = "Results";
+      resultsCollector.Successor = mainLoop;
+
+      mainLoop.MoveGeneratorParameter.ActualName = MoveGeneratorParameter.Name;
+      mainLoop.MoveEvaluatorParameter.ActualName = MoveEvaluatorParameter.Name;
+      mainLoop.MoveMakerParameter.ActualName = MoveMakerParameter.Name;
+      mainLoop.AnnealingOperatorParameter.ActualName = AnnealingOperatorParameter.Name;
+      mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
+      mainLoop.TemperatureParameter.ActualName = "Temperature";
+      mainLoop.StartTemperatureParameter.ActualName = StartTemperatureParameter.Name;
+      mainLoop.EndTemperatureParameter.ActualName = EndTemperatureParameter.Name;
+      mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+      mainLoop.ResultsParameter.ActualName = "Results";
+      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
+      mainLoop.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
+      mainLoop.IterationsParameter.ActualName = "Iterations";
+
+      foreach (IDiscreteDoubleValueModifier op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
+        AnnealingOperatorParameter.ValidValues.Add(op);
+      ParameterizeAnnealingOperators();
+
+      qualityAnalyzer = new QualityAnalyzer();
+      temperatureAnalyzer = new SingleValueAnalyzer();
+      temperatureAnalyzer.Name = "TemperatureAnalyzer";
+      ParameterizeAnalyzers();
+      UpdateAnalyzers();
+
+      Initialize();
+    }
+
+    public override void Prepare() {
+      if (Problem != null && MoveGenerator != null && MoveMaker != null && MoveEvaluator != null)
+        base.Prepare();
+    }
+
+    #region Events
+    protected override void OnProblemChanged() {
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeStochasticOperator(Problem.Evaluator);
+      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
+      foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>()) {
+        op.MoveQualityParameter.ActualNameChanged += new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
+      }
+      ParameterizeSolutionsCreator();
+      ParameterizeMainLoop();
+      UpdateMoveGenerator();
+      UpdateMoveParameters();
+      UpdateAnalyzers();
+      ParameterizeMoveEvaluators();
+      ParameterizeMoveMakers();
+      ParameterizeMoveGenerators();
+      ParameterizeAnalyzers();
+      ParameterizeIterationBasedOperators();
+      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      base.OnProblemChanged();
+    }
+    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeSolutionsCreator();
+      base.Problem_SolutionCreatorChanged(sender, e);
+    }
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      ParameterizeStochasticOperator(Problem.Evaluator);
+      ParameterizeSolutionsCreator();
+      ParameterizeMainLoop();
+      ParameterizeMoveEvaluators();
+      ParameterizeMoveMakers();
+      ParameterizeAnalyzers();
+      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      base.Problem_EvaluatorChanged(sender, e);
+    }
+    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
+      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
+      // This may seem pointless, but some operators already have the eventhandler registered, others don't
+      // FIXME: Is there another way to solve this problem?
+      foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>()) {
+        op.MoveQualityParameter.ActualNameChanged -= new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
+        op.MoveQualityParameter.ActualNameChanged += new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
+      }
+      UpdateMoveGenerator();
+      UpdateMoveParameters();
+      UpdateAnalyzers();
+      ParameterizeMainLoop();
+      ParameterizeMoveEvaluators();
+      ParameterizeMoveMakers();
+      ParameterizeMoveGenerators();
+      ParameterizeIterationBasedOperators();
+      base.Problem_OperatorsChanged(sender, e);
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeMainLoop();
+      ParameterizeMoveEvaluators();
+      ParameterizeMoveMakers();
+      ParameterizeAnalyzers();
+    }
+    private void MoveGeneratorParameter_ValueChanged(object sender, EventArgs e) {
+      UpdateMoveParameters();
+    }
+    private void MoveEvaluatorParameter_ValueChanged(object sender, EventArgs e) {
+      ParameterizeMainLoop();
+      ParameterizeMoveEvaluators();
+      ParameterizeMoveMakers();
+    }
+    private void MoveEvaluator_MoveQualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeMainLoop();
+      ParameterizeMoveEvaluators();
+      ParameterizeMoveMakers();
+    }
+    #endregion
+
+    #region Helpers
+    private void Initialize() {
+      if (Problem != null) {
+        Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+        foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>()) {
+          op.MoveQualityParameter.ActualNameChanged += new EventHandler(MoveEvaluator_MoveQualityParameter_ActualNameChanged);
+        }
+      }
+      MoveGeneratorParameter.ValueChanged += new EventHandler(MoveGeneratorParameter_ValueChanged);
+      MoveEvaluatorParameter.ValueChanged += new EventHandler(MoveEvaluatorParameter_ValueChanged);
+    }
+    private void UpdateMoveGenerator() {
+      IMultiMoveGenerator oldMoveGenerator = MoveGenerator;
+      IMultiMoveGenerator defaultMoveGenerator = Problem.Operators.OfType<IMultiMoveGenerator>().FirstOrDefault();
+      MoveGeneratorParameter.ValidValues.Clear();
+      if (Problem != null) {
+        foreach (IMultiMoveGenerator generator in Problem.Operators.OfType<IMultiMoveGenerator>().OrderBy(x => x.Name))
+          MoveGeneratorParameter.ValidValues.Add(generator);
+      }
+      if (oldMoveGenerator != null) {
+        IMultiMoveGenerator newMoveGenerator = MoveGeneratorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveGenerator.GetType());
+        if (newMoveGenerator != null) MoveGenerator = newMoveGenerator;
+        else oldMoveGenerator = null;
+      }
+      if (oldMoveGenerator == null && defaultMoveGenerator != null)
+        MoveGenerator = defaultMoveGenerator;
+      if (MoveGenerator == null) {
+        ClearMoveParameters();
+      }
+    }
+    private void ParameterizeAnalyzers() {
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      if (Problem != null) {
+        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        qualityAnalyzer.MaximizationParameter.Hidden = true;
+        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        qualityAnalyzer.QualityParameter.Depth = 0;
+        qualityAnalyzer.QualityParameter.Hidden = true;
+        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
+      } else {
+        qualityAnalyzer.MaximizationParameter.Hidden = false;
+        qualityAnalyzer.QualityParameter.Hidden = false;
+        qualityAnalyzer.BestKnownQualityParameter.Hidden = false;
+        temperatureAnalyzer.ResultsParameter.ActualName = "Results";
+        temperatureAnalyzer.ValueParameter.ActualName = "Temperature";
+        temperatureAnalyzer.ValuesParameter.ActualName = "Temperature Chart";
+      }
+    }
+    private void UpdateMoveParameters() {
+      IMoveMaker oldMoveMaker = MoveMaker;
+      ISingleObjectiveMoveEvaluator oldMoveEvaluator = MoveEvaluator;
+      ClearMoveParameters();
+
+      if (MoveGenerator != null) {
+        List<Type> moveTypes = MoveGenerator.GetType().GetInterfaces().Where(x => typeof(IMoveOperator).IsAssignableFrom(x)).ToList();
+        foreach (Type type in moveTypes.ToList()) {
+          if (moveTypes.Any(t => t != type && type.IsAssignableFrom(t)))
+            moveTypes.Remove(type);
+        }
+        var operators = Problem.Operators.Where(op => moveTypes.Any(m => m.IsInstanceOfType(op))).ToList();
+        IMoveMaker defaultMoveMaker = operators.OfType<IMoveMaker>().FirstOrDefault();
+        ISingleObjectiveMoveEvaluator defaultMoveEvaluator = operators.OfType<ISingleObjectiveMoveEvaluator>().FirstOrDefault();
+
+        foreach (IMoveMaker moveMaker in operators.OfType<IMoveMaker>().OrderBy(op => op.Name))
+          MoveMakerParameter.ValidValues.Add(moveMaker);
+        foreach (ISingleObjectiveMoveEvaluator moveEvaluator in operators.OfType<ISingleObjectiveMoveEvaluator>().OrderBy(op => op.Name))
+          MoveEvaluatorParameter.ValidValues.Add(moveEvaluator);
+
+        if (oldMoveMaker != null) {
+          IMoveMaker mm = MoveMakerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveMaker.GetType());
+          if (mm != null) MoveMaker = mm;
+          else oldMoveMaker = null;
+        }
+        if (oldMoveMaker == null && defaultMoveMaker != null)
+          MoveMaker = defaultMoveMaker;
+
+        if (oldMoveEvaluator != null) {
+          ISingleObjectiveMoveEvaluator me = MoveEvaluatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveEvaluator.GetType());
+          if (me != null) MoveEvaluator = me;
+          else oldMoveEvaluator = null;
+        }
+        if (oldMoveEvaluator == null & defaultMoveEvaluator != null)
+          MoveEvaluator = defaultMoveEvaluator;
+      }
+    }
+    private void ClearMoveParameters() {
+      MoveMakerParameter.ValidValues.Clear();
+      MoveEvaluatorParameter.ValidValues.Clear();
+    }
+    private void ParameterizeSolutionsCreator() {
+      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+    }
+    private void ParameterizeMainLoop() {
+      if (Problem != null) {
+        MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+      }
+      if (MoveEvaluator != null)
+        MainLoop.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
+    }
+    private void ParameterizeStochasticOperator(IOperator op) {
+      if (op is IStochasticOperator) {
+        IStochasticOperator stOp = (IStochasticOperator)op;
+        stOp.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+        stOp.RandomParameter.Hidden = true;
+      }
+    }
+    private void ParameterizeMoveEvaluators() {
+      foreach (ISingleObjectiveMoveEvaluator op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>()) {
+        op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        op.QualityParameter.Hidden = true;
+      }
+    }
+    private void ParameterizeMoveMakers() {
+      foreach (IMoveMaker op in Problem.Operators.OfType<IMoveMaker>()) {
+        op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        op.QualityParameter.Hidden = true;
+        if (MoveEvaluator != null) {
+          op.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
+          op.MoveQualityParameter.Hidden = true;
+        } else {
+          op.MoveQualityParameter.Hidden = false;
+        }
+      }
+    }
+    private void ParameterizeAnnealingOperators() {
+      foreach (IDiscreteDoubleValueModifier op in AnnealingOperatorParameter.ValidValues) {
+        op.IndexParameter.ActualName = "Iterations";
+        op.IndexParameter.Hidden = true;
+        op.StartIndexParameter.Value = new IntValue(0);
+        op.EndIndexParameter.ActualName = MaximumIterationsParameter.Name;
+        op.ValueParameter.ActualName = "Temperature";
+        op.ValueParameter.Hidden = true;
+        op.StartValueParameter.ActualName = StartTemperatureParameter.Name;
+        op.StartValueParameter.Hidden = true;
+        op.EndValueParameter.ActualName = EndTemperatureParameter.Name;
+        op.EndValueParameter.Hidden = true;
+        ParameterizeStochasticOperator(op);
+      }
+    }
+    private void ParameterizeMoveGenerators() {
+      foreach (IMultiMoveGenerator op in Problem.Operators.OfType<IMultiMoveGenerator>()) {
+        op.SampleSizeParameter.ActualName = InnerIterationsParameter.Name;
+        op.SampleSizeParameter.Hidden = true;
+      }
+    }
+    private void ParameterizeIterationBasedOperators() {
+      if (Problem != null) {
+        foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
+          op.IterationsParameter.ActualName = "Iterations";
+          op.IterationsParameter.Hidden = true;
+          op.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
+          op.MaximumIterationsParameter.Hidden = true;
+        }
+      }
+    }
+    private void UpdateAnalyzers() {
+      Analyzer.Operators.Clear();
+      if (Problem != null) {
+        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
+          foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
+            param.Depth = 0;
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+        }
+      }
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(temperatureAnalyzer, temperatureAnalyzer.EnabledByDefault);
+    }
+    private SimulatedAnnealingMainLoop FindMainLoop(IOperator start) {
+      IOperator mainLoop = start;
+      while (mainLoop != null && !(mainLoop is SimulatedAnnealingMainLoop))
+        mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
+      if (mainLoop == null) return null;
+      else return (SimulatedAnnealingMainLoop)mainLoop;
+    }
+    #endregion
+  }
+}
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs	(revision 14406)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingImprovementOperator.cs	(revision 14406)
@@ -0,0 +1,391 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing {
+  /// <summary>
+  /// A simulated annealing improvement operator.
+  /// </summary>
+  [Item("SimulatedAnnealingImprovementOperator", "A simulated annealing improvement operator.")]
+  [StorableClass]
+  public sealed class SimulatedAnnealingImprovementOperator : SingleSuccessorOperator, ILocalImprovementAlgorithmOperator, IStochasticOperator, ISingleObjectiveOperator {
+    #region IGenericLocalImprovementOperator Properties
+    public Type ProblemType { get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); } }
+    public IProblem Problem {
+      get { return problem; }
+      set {
+        if (problem != value) {
+          if (value != null && !(value is ISingleObjectiveHeuristicOptimizationProblem))
+            throw new ArgumentException("Only problems of type " + ProblemType.ToString() + " can be assigned.");
+          if (problem != null) DeregisterProblemEventHandlers();
+          problem = (ISingleObjectiveHeuristicOptimizationProblem)value;
+          if (problem != null) RegisterProblemEventHandlers();
+          UpdateProblem();
+        }
+      }
+    }
+    #endregion
+
+    [Storable]
+    private ISingleObjectiveHeuristicOptimizationProblem problem;
+    [Storable]
+    private SimulatedAnnealingMainLoop loop;
+    [Storable]
+    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
+
+    #region Parameter Properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IConstrainedValueParameter<IMoveGenerator> MoveGeneratorParameter {
+      get { return (IConstrainedValueParameter<IMoveGenerator>)Parameters["MoveGenerator"]; }
+    }
+    public IConstrainedValueParameter<IMoveMaker> MoveMakerParameter {
+      get { return (IConstrainedValueParameter<IMoveMaker>)Parameters["MoveMaker"]; }
+    }
+    public IConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter {
+      get { return (IConstrainedValueParameter<ISingleObjectiveMoveEvaluator>)Parameters["MoveEvaluator"]; }
+    }
+    private IValueLookupParameter<IntValue> InnerIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["InnerIterations"]; }
+    }
+    public ValueParameter<MultiAnalyzer> AnalyzerParameter {
+      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
+    }
+    private ValueParameter<DoubleValue> StartTemperatureParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["StartTemperature"]; }
+    }
+    private ValueParameter<DoubleValue> EndTemperatureParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["EndTemperature"]; }
+    }
+    public IConstrainedValueParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter {
+      get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["AnnealingOperator"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    #region ILocalImprovementOperator Parameters
+    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"]; }
+    }
+    #endregion
+    #endregion
+
+    #region Properties
+    public IMoveGenerator MoveGenerator {
+      get { return MoveGeneratorParameter.Value; }
+      set { MoveGeneratorParameter.Value = value; }
+    }
+    public IMoveMaker MoveMaker {
+      get { return MoveMakerParameter.Value; }
+      set { MoveMakerParameter.Value = value; }
+    }
+    public IDiscreteDoubleValueModifier AnnealingOperator {
+      get { return AnnealingOperatorParameter.Value; }
+      set { AnnealingOperatorParameter.Value = value; }
+    }
+    public ISingleObjectiveMoveEvaluator MoveEvaluator {
+      get { return MoveEvaluatorParameter.Value; }
+      set { MoveEvaluatorParameter.Value = value; }
+    }
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+      set { AnalyzerParameter.Value = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SimulatedAnnealingImprovementOperator(bool deserializing) : base(deserializing) { }
+    private SimulatedAnnealingImprovementOperator(SimulatedAnnealingImprovementOperator original, Cloner cloner)
+      : base(original, cloner) {
+      this.problem = cloner.Clone(original.problem);
+      this.loop = cloner.Clone(original.loop);
+      this.qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      RegisterEventHandlers();
+    }
+    public SimulatedAnnealingImprovementOperator()
+      : base() {
+      loop = new SimulatedAnnealingMainLoop();
+
+      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new ConstrainedValueParameter<IMoveGenerator>("MoveGenerator", "The operator used to generate moves to the neighborhood of the current solution."));
+      Parameters.Add(new ConstrainedValueParameter<IMoveMaker>("MoveMaker", "The operator used to perform a move."));
+      Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>("MoveEvaluator", "The operator used to evaluate a move."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(150)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("InnerIterations", "Number of moves that MultiMoveGenerators should create. This is ignored for Exhaustive- and SingleMoveGenerators.", new IntValue(1500)));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated moves."));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution.", new MultiAnalyzer()));
+      Parameters.Add(new ValueParameter<DoubleValue>("StartTemperature", "The initial temperature.", new DoubleValue(100)));
+      Parameters.Add(new ValueParameter<DoubleValue>("EndTemperature", "The final temperature which should be reached when iterations reaches maximum iterations.", new DoubleValue(1e-6)));
+      Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>("AnnealingOperator", "The operator used to modify the temperature."));
+      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The variable where the results are stored."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality/fitness value of a solution."));
+
+      foreach (IDiscreteDoubleValueModifier op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
+        AnnealingOperatorParameter.ValidValues.Add(op);
+
+      ParameterizeAnnealingOperators();
+      ParameterizeSAMainLoop();
+
+      RegisterEventHandlers();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SimulatedAnnealingImprovementOperator(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    #region Event Handler Registration
+    private void RegisterEventHandlers() {
+      MoveGeneratorParameter.ValueChanged += new EventHandler(MoveGeneratorParameter_ValueChanged);
+      if (problem != null)
+        RegisterProblemEventHandlers();
+    }
+
+    private void RegisterProblemEventHandlers() {
+      problem.Reset += new EventHandler(problem_Reset);
+      problem.OperatorsChanged += new EventHandler(problem_OperatorsChanged);
+    }
+
+    private void DeregisterProblemEventHandlers() {
+      problem.Reset -= new EventHandler(problem_Reset);
+      problem.OperatorsChanged -= new EventHandler(problem_OperatorsChanged);
+    }
+    #endregion
+
+    #region Event Handlers
+    private void MoveGeneratorParameter_ValueChanged(object sender, EventArgs e) {
+      ChooseMoveOperators();
+      ParameterizeSAMainLoop();
+    }
+
+    private void problem_Reset(object sender, EventArgs e) {
+      UpdateProblem();
+    }
+
+    private void problem_OperatorsChanged(object sender, EventArgs e) {
+      UpdateProblem();
+    }
+    #endregion
+
+    private void ParameterizeAnnealingOperators() {
+      foreach (IDiscreteDoubleValueModifier op in AnnealingOperatorParameter.ValidValues) {
+        op.IndexParameter.ActualName = "LocalIterations";
+        op.StartIndexParameter.Value = new IntValue(0);
+        op.EndIndexParameter.ActualName = MaximumIterationsParameter.Name;
+        op.ValueParameter.ActualName = "Temperature";
+        op.StartValueParameter.ActualName = StartTemperatureParameter.Name;
+        op.EndValueParameter.ActualName = EndTemperatureParameter.Name;
+      }
+    }
+
+    public void UpdateProblem() {
+      UpdateMoveOperators();
+      ChooseMoveOperators();
+
+      ParameterizeMoveGenerators();
+
+      ParameterizeSAMainLoop();
+      ParameterizeAnalyzers();
+      UpdateAnalyzers();
+    }
+
+    private void ParameterizeAnalyzers() {
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      if (problem != null) {
+        qualityAnalyzer.MaximizationParameter.ActualName = problem.MaximizationParameter.Name;
+        qualityAnalyzer.QualityParameter.ActualName = problem.Evaluator.QualityParameter.Name;
+        qualityAnalyzer.QualityParameter.Depth = 0;
+        qualityAnalyzer.BestKnownQualityParameter.ActualName = problem.BestKnownQualityParameter.Name;
+      }
+    }
+
+    private void ParameterizeSAMainLoop() {
+      loop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
+      loop.EvaluatedMovesParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      loop.IterationsParameter.ActualName = "LocalIterations";
+      loop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
+      loop.MoveEvaluatorParameter.ActualName = MoveEvaluatorParameter.Name;
+      loop.MoveGeneratorParameter.ActualName = MoveGeneratorParameter.Name;
+      loop.MoveMakerParameter.ActualName = MoveMakerParameter.Name;
+      loop.QualityParameter.ActualName = QualityParameter.Name;
+      loop.RandomParameter.ActualName = RandomParameter.Name;
+      loop.ResultsParameter.ActualName = ResultsParameter.Name;
+
+      if (problem != null) {
+        loop.BestKnownQualityParameter.ActualName = problem.BestKnownQualityParameter.Name;
+        loop.MaximizationParameter.ActualName = problem.MaximizationParameter.Name;
+      }
+      if (MoveEvaluator != null) {
+        loop.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
+      }
+    }
+
+    private bool IsSubclassOfGeneric(Type generic, Type toCheck) {
+      while (toCheck != typeof(object)) {
+        var cur = toCheck.IsGenericType ? toCheck.GetGenericTypeDefinition() : toCheck;
+        if (generic == cur) {
+          return true;
+        }
+        toCheck = toCheck.BaseType;
+      }
+      return false;
+    }
+
+    private void UpdateAnalyzers() {
+      Analyzer.Operators.Clear();
+      if (problem != null) {
+        foreach (IAnalyzer analyzer in problem.Operators.OfType<IAnalyzer>()) {
+          if (!IsSubclassOfGeneric(typeof(AlleleFrequencyAnalyzer<>), analyzer.GetType()) &&
+              !(analyzer is PopulationSimilarityAnalyzer)) {
+            IAnalyzer clone = analyzer.Clone() as IAnalyzer;
+            foreach (IScopeTreeLookupParameter param in clone.Parameters.OfType<IScopeTreeLookupParameter>())
+              param.Depth = 0;
+            Analyzer.Operators.Add(clone, false);
+          }
+        }
+      }
+      Analyzer.Operators.Add(qualityAnalyzer, false);
+    }
+
+    private void UpdateMoveOperators() {
+      IMoveGenerator oldMoveGenerator = MoveGenerator;
+      IMoveMaker oldMoveMaker = MoveMaker;
+      ISingleObjectiveMoveEvaluator oldMoveEvaluator = MoveEvaluator;
+
+      ClearMoveParameters();
+
+      if (problem != null) {
+        foreach (IMultiMoveGenerator generator in problem.Operators.OfType<IMultiMoveGenerator>().OrderBy(x => x.Name))
+          MoveGeneratorParameter.ValidValues.Add(generator);
+        foreach (IExhaustiveMoveGenerator generator in problem.Operators.OfType<IExhaustiveMoveGenerator>().OrderBy(x => x.Name))
+          MoveGeneratorParameter.ValidValues.Add(generator);
+
+        if (oldMoveGenerator != null) {
+          IMoveGenerator newMoveGenerator = MoveGeneratorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveGenerator.GetType());
+          if (newMoveGenerator != null) MoveGenerator = newMoveGenerator;
+        }
+
+        ChooseMoveOperators(oldMoveMaker, oldMoveEvaluator);
+      }
+    }
+
+    private void ChooseMoveOperators(IMoveMaker oldMoveMaker = null, ISingleObjectiveMoveEvaluator oldMoveEvaluator = null) {
+      if (oldMoveMaker == null) oldMoveMaker = MoveMaker;
+      if (oldMoveEvaluator == null) oldMoveEvaluator = MoveEvaluator;
+      MoveMakerParameter.ValidValues.Clear();
+      MoveEvaluatorParameter.ValidValues.Clear();
+
+      if (MoveGenerator != null) {
+        IMoveGenerator generator = MoveGeneratorParameter.Value;
+        foreach (IMoveMaker moveMaker in MoveHelper.GetCompatibleMoveMakers(generator, Problem.Operators.OfType<IOperator>()).OrderBy(x => x.Name))
+          MoveMakerParameter.ValidValues.Add(moveMaker);
+        foreach (ISingleObjectiveMoveEvaluator moveEvaluator in MoveHelper.GetCompatibleSingleObjectiveMoveEvaluators(generator, Problem.Operators.OfType<IOperator>()).OrderBy(x => x.Name))
+          MoveEvaluatorParameter.ValidValues.Add(moveEvaluator);
+
+        if (oldMoveMaker != null) {
+          IMoveMaker mm = MoveMakerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveMaker.GetType());
+          if (mm != null) MoveMaker = mm;
+        }
+        if (oldMoveEvaluator != null) {
+          ISingleObjectiveMoveEvaluator me = MoveEvaluatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveEvaluator.GetType());
+          if (me != null) MoveEvaluator = me;
+        }
+      }
+    }
+
+    private void ClearMoveParameters() {
+      MoveGeneratorParameter.ValidValues.Clear();
+      MoveMakerParameter.ValidValues.Clear();
+      MoveEvaluatorParameter.ValidValues.Clear();
+    }
+
+    private void ParameterizeMoveGenerators() {
+      if (problem != null) {
+        foreach (IMultiMoveGenerator generator in problem.Operators.OfType<IMultiMoveGenerator>())
+          generator.SampleSizeParameter.ActualName = InnerIterationsParameter.Name;
+      }
+    }
+
+    public override IOperation Apply() {
+      IScope currentScope = ExecutionContext.Scope;
+
+      Scope localScope = new Scope();
+      Scope individual = new Scope();
+
+      foreach (IVariable var in currentScope.Variables)
+        individual.Variables.Add(var); // add reference to variable otherwise the analyzer fails (it's looking down the tree)
+
+      localScope.SubScopes.Add(individual);
+      currentScope.SubScopes.Add(localScope);
+      int index = currentScope.SubScopes.Count - 1;
+
+      SubScopesProcessor processor = new SubScopesProcessor();
+      SubScopesRemover remover = new SubScopesRemover();
+
+      remover.RemoveAllSubScopes = false;
+      remover.SubScopeIndexParameter.Value = new IntValue(index);
+
+      if (index > 0) {
+        EmptyOperator eo = new EmptyOperator();
+        for (int i = 0; i < index - 1; i++) {
+          processor.Operators.Add(eo);
+        }
+      }
+
+      VariableCreator variableCreator = new VariableCreator();
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(loop.IterationsParameter.ActualName, new IntValue(0)));
+
+      variableCreator.Successor = loop;
+
+      processor.Operators.Add(variableCreator);
+      processor.Successor = remover;
+
+      OperationCollection next = new OperationCollection(base.Apply());
+      next.Insert(0, ExecutionContext.CreateChildOperation(processor));
+
+      return next;
+    }
+  }
+}
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs	(revision 14406)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs	(revision 14406)
@@ -0,0 +1,254 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing {
+  /// <summary>
+  /// An operator which represents a simulated annealing.
+  /// </summary>
+  [Item("SimulatedAnnealingMainLoop", "An operator which represents the main loop of a simulated annealing algorithm.")]
+  [StorableClass]
+  public sealed class SimulatedAnnealingMainLoop : AlgorithmOperator {
+    #region Parameter properties
+    public ValueLookupParameter<IRandom> RandomParameter {
+      get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public LookupParameter<DoubleValue> QualityParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ValueLookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    public LookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> TemperatureParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Temperature"]; }
+    }
+    public ValueLookupParameter<DoubleValue> StartTemperatureParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["StartTemperature"]; }
+    }
+    public ValueLookupParameter<DoubleValue> EndTemperatureParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["EndTemperature"]; }
+    }
+    public ValueLookupParameter<IntValue> InnerIterationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["InnerIterations"]; }
+    }
+    public LookupParameter<IntValue> IterationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters["Iterations"]; }
+    }
+    public ValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+    public ValueLookupParameter<IOperator> MoveGeneratorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["MoveGenerator"]; }
+    }
+    public ValueLookupParameter<IOperator> MoveEvaluatorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["MoveEvaluator"]; }
+    }
+    public ValueLookupParameter<IOperator> MoveMakerParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["MoveMaker"]; }
+    }
+    public ValueLookupParameter<IOperator> AnnealingOperatorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["AnnealingOperator"]; }
+    }
+    public ValueLookupParameter<IOperator> AnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
+    }
+    public ValueLookupParameter<VariableCollection> ResultsParameter {
+      get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
+    }
+    public LookupParameter<IntValue> EvaluatedMovesParameter {
+      get { return (LookupParameter<IntValue>)Parameters["EvaluatedMoves"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SimulatedAnnealingMainLoop(bool deserializing) : base(deserializing) { }
+    private SimulatedAnnealingMainLoop(SimulatedAnnealingMainLoop original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SimulatedAnnealingMainLoop(this, cloner);
+    }
+    public SimulatedAnnealingMainLoop()
+      : base() {
+      Initialize();
+    }
+
+    private void Initialize() {
+      #region Create parameters
+      Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Temperature", "The current temperature."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("StartTemperature", "The initial temperature."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("EndTemperature", "The end temperature."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again)."));
+      Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("MoveGenerator", "The operator that generates the moves."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("MoveEvaluator", "The operator that evaluates a move."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("AnnealingOperator", "The operator that modifies the temperature."));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
+      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of evaluated moves."));
+      #endregion
+
+      #region Create operators
+      Assigner temperatureInitializer = new Assigner();
+      ResultsCollector resultsCollector1 = new ResultsCollector();
+      SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
+      Placeholder analyzer1 = new Placeholder();
+      SubScopesProcessor sssp = new SubScopesProcessor();
+      ResultsCollector resultsCollector = new ResultsCollector();
+      Placeholder annealingOperator = new Placeholder();
+      UniformSubScopesProcessor mainProcessor = new UniformSubScopesProcessor();
+      Placeholder moveGenerator = new Placeholder();
+      UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
+      Placeholder moveEvaluator = new Placeholder();
+      SubScopesCounter subScopesCounter = new SubScopesCounter();
+      ProbabilisticQualityComparator qualityComparator = new ProbabilisticQualityComparator();
+      ConditionalBranch improvesQualityBranch = new ConditionalBranch();
+      Placeholder moveMaker = new Placeholder();
+      SubScopesRemover subScopesRemover = new SubScopesRemover();
+      IntCounter iterationsCounter = new IntCounter();
+      Comparator iterationsComparator = new Comparator();
+      SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
+      Placeholder analyzer2 = new Placeholder();
+      ConditionalBranch iterationsTermination = new ConditionalBranch();
+
+      temperatureInitializer.LeftSideParameter.ActualName = TemperatureParameter.ActualName;
+      temperatureInitializer.RightSideParameter.ActualName = StartTemperatureParameter.Name;
+
+      resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>(IterationsParameter.Name));
+      resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
+
+      analyzer1.Name = "Analyzer (placeholder)";
+      analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+      annealingOperator.Name = "Annealing operator (placeholder)";
+      annealingOperator.OperatorParameter.ActualName = AnnealingOperatorParameter.Name;
+
+      moveGenerator.Name = "Move generator (placeholder)";
+      moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
+
+      moveEvaluator.Name = "Move evaluator (placeholder)";
+      moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
+
+      subScopesCounter.Name = "Increment EvaluatedMoves";
+      subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
+
+      qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
+      qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
+      qualityComparator.ResultParameter.ActualName = "IsBetter";
+      qualityComparator.DampeningParameter.ActualName = "Temperature";
+
+      improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
+
+      moveMaker.Name = "Move maker (placeholder)";
+      moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
+
+      subScopesRemover.RemoveAllSubScopes = true;
+
+      iterationsCounter.Name = "Increment Iterations";
+      iterationsCounter.Increment = new IntValue(1);
+      iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
+
+      iterationsComparator.Name = "Iterations >= MaximumIterations";
+      iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
+      iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
+      iterationsComparator.ResultParameter.ActualName = "Terminate";
+      iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
+
+      analyzer2.Name = "Analyzer (placeholder)";
+      analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+      iterationsTermination.Name = "Iterations termination condition";
+      iterationsTermination.ConditionParameter.ActualName = "Terminate";
+      #endregion
+
+      #region Create operator graph
+      OperatorGraph.InitialOperator = temperatureInitializer;
+      temperatureInitializer.Successor = resultsCollector1;
+      resultsCollector1.Successor = subScopesProcessor0;
+      subScopesProcessor0.Operators.Add(analyzer1);
+      subScopesProcessor0.Successor = sssp;
+      analyzer1.Successor = null;
+      sssp.Operators.Add(resultsCollector);
+      sssp.Successor = annealingOperator;
+      resultsCollector.Successor = null;
+      annealingOperator.Successor = mainProcessor;
+      mainProcessor.Operator = moveGenerator;
+      mainProcessor.Successor = iterationsCounter;
+      moveGenerator.Successor = moveEvaluationProcessor;
+      moveEvaluationProcessor.Operator = moveEvaluator;
+      moveEvaluationProcessor.Successor = subScopesCounter;
+      moveEvaluator.Successor = qualityComparator;
+      qualityComparator.Successor = improvesQualityBranch;
+      improvesQualityBranch.TrueBranch = moveMaker;
+      improvesQualityBranch.FalseBranch = null;
+      improvesQualityBranch.Successor = null;
+      moveMaker.Successor = null;
+      subScopesCounter.Successor = subScopesRemover;
+      subScopesRemover.Successor = null;
+      iterationsCounter.Successor = iterationsComparator;
+      iterationsComparator.Successor = subScopesProcessor1;
+      subScopesProcessor1.Operators.Add(analyzer2);
+      subScopesProcessor1.Successor = iterationsTermination;
+      iterationsTermination.TrueBranch = null;
+      iterationsTermination.FalseBranch = annealingOperator;
+      #endregion
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code (remove with 3.4)
+      if (!Parameters.ContainsKey("Iterations"))
+        Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations."));
+      if (!Parameters.ContainsKey("Temperature"))
+        Parameters.Add(new LookupParameter<DoubleValue>("Temperature", "The current temperature."));
+      #endregion
+    }
+
+    public override IOperation Apply() {
+      if (MoveGeneratorParameter.ActualValue == null || MoveEvaluatorParameter.ActualValue == null || MoveMakerParameter.ActualValue == null)
+        return null;
+      return base.Apply();
+    }
+  }
+}
Index: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/obj/Release/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.FileListAbsolute.txt
===================================================================
--- branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/obj/Release/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.FileListAbsolute.txt	(revision 14406)
+++ branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/obj/Release/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.FileListAbsolute.txt	(revision 14406)
@@ -0,0 +1,4 @@
+C:\Users\JS\Desktop\FH\MASTER\Masterarbeit\hl\bin\HeuristicLab.Algorithms.SimulatedAnnealing-3.3.dll
+C:\Users\JS\Desktop\FH\MASTER\Masterarbeit\hl\bin\HeuristicLab.Algorithms.SimulatedAnnealing-3.3.pdb
+C:\Users\JS\Desktop\FH\MASTER\Masterarbeit\hl\HeuristicLab.Algorithms.SimulatedAnnealing\3.3\obj\Release\HeuristicLab.Algorithms.SimulatedAnnealing-3.3.dll
+C:\Users\JS\Desktop\FH\MASTER\Masterarbeit\hl\HeuristicLab.Algorithms.SimulatedAnnealing\3.3\obj\Release\HeuristicLab.Algorithms.SimulatedAnnealing-3.3.pdb
