Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs	(revision 14743)
@@ -0,0 +1,216 @@
+﻿using HeuristicLab.Operators;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Analysis;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("AcceptanceRatioReheatingOperator", "Reheats the temperature if the acceptance is below a threshold.")]
+    [StorableClass]
+    public class AcceptanceRatioReheatingOperator : SingleSuccessorOperator, IReheatingOperator
+    {
+        #region Strings
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string MaximumIterationsName = "MaximumIterations";
+
+        private const string UpperTemperatureName = "UpperTemperature";
+        private const string ReheatingOperatorName = "ReheatingOperator";
+        private const string ThresholdName = "Threshold";
+        private const string MemorySizeName = "MemorySize";
+        private const string CoolingName = "Cooling";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+
+
+        #endregion
+        #region Parameters
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> EndTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public ILookupParameter<IOperator> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        }
+        public ILookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        private ValueParameter<DoubleValue> UpperTemperatureParameter
+        {
+            get { return (ValueParameter<DoubleValue>)Parameters[UpperTemperatureName]; }
+        }
+        private IConstrainedValueParameter<IDiscreteDoubleValueModifier> ReheatingOperatorParameter
+        {
+            get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters[ReheatingOperatorName]; }
+        }
+        private ValueParameter<DoubleRange> ThresholdParameter
+        {
+            get { return (ValueParameter<DoubleRange>)Parameters[ThresholdName]; }
+        }
+        private ValueParameter<IntValue> MemorySizeParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[MemorySizeName]; }
+        }
+        public ILookupParameter<BoolValue> CoolingParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[CoolingName]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<ItemList<BoolValue>> AcceptanceMemoryParameter
+        {
+            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
+        }
+
+        #endregion
+
+        public AcceptanceRatioReheatingOperator() : base()
+        {
+            #region Create parameters
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new LookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
+            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled or heated."));
+            Parameters.Add(new LookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
+            Parameters.Add(new LookupParameter<BoolValue>(IsAcceptedName, "Whether the move was accepted or not."));
+            Parameters.Add(new LookupParameter<ItemList<BoolValue>>(AcceptanceMemoryName, "Memorizes the last N acceptance decisions."));
+            Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
+            Parameters.Add(new ValueParameter<DoubleValue>(UpperTemperatureName, "The upper bound of the temperature.", new DoubleValue(100d)));
+            Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>(ReheatingOperatorName, "The operator that reheats the temperature."));
+            Parameters.Add(new ValueParameter<DoubleRange>(ThresholdName, "The threshold controls the temperature. If the average ratio of accepted moves goes below the start of the range the temperature is heated. If the the average ratio of accepted moves goes beyond the end of the range the temperature is cooled again.", new DoubleRange(0.2, 0.1)));
+            Parameters.Add(new ValueParameter<IntValue>(MemorySizeName, "The maximum size of the acceptance memory.", new IntValue(100)));
+
+            #endregion
+
+            foreach (var op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
+            {
+                ReheatingOperatorParameter.ValidValues.Add((IDiscreteDoubleValueModifier) op);
+            }
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected AcceptanceRatioReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected AcceptanceRatioReheatingOperator(AcceptanceRatioReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new AcceptanceRatioReheatingOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+            foreach (var op in ReheatingOperatorParameter.ValidValues)
+            {
+                op.IndexParameter.ActualName = IterationsName;
+                op.IndexParameter.Hidden = true;
+                op.StartIndexParameter.Value = null;
+                op.StartIndexParameter.ActualName = TemperatureStartIndexName;
+                op.EndIndexParameter.ActualName = MaximumIterationsParameter.Name;
+                op.ValueParameter.ActualName = TemperatureName;
+                op.ValueParameter.Hidden = true;
+                op.StartValueParameter.ActualName = StartTemperatureName;
+                op.StartValueParameter.Hidden = true;
+                op.EndValueParameter.ActualName = UpperTemperatureName;
+                op.EndValueParameter.Value = UpperTemperatureParameter.Value;
+                op.EndValueParameter.Hidden = true;
+            }
+        }
+
+        public override IOperation Apply()
+        {
+
+            var acceptances = AcceptanceMemoryParameter.ActualValue;
+            var cooling = CoolingParameter.ActualValue.Value;
+
+            acceptances.Add(IsAcceptedParameter.ActualValue);
+
+            if (acceptances.Count > MemorySizeParameter.Value.Value) acceptances.RemoveAt(0);
+
+            var ratioStart = ThresholdParameter.Value.Start;
+            var ratioEnd = ThresholdParameter.Value.End;
+            var ratio = acceptances.Average(x => x.Value ? 1.0 : 0.0);
+
+            
+            if (!cooling && ratio >= ratioEnd)
+            {
+                // if we are heating, but should be cooling
+                cooling = true;
+                TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+                StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+                EndTemperatureParameter.ActualValue.Value = LowerTemperatureParameter.ActualValue.Value;
+            }
+            else if (cooling && ratio <= ratioStart)
+            {
+                // if we are cooling but should be heating
+                cooling = false;
+                TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+                StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+                EndTemperatureParameter.ActualValue.Value = UpperTemperatureParameter.Value.Value;
+            }
+
+            CoolingParameter.ActualValue.Value = cooling;
+
+            return cooling ? Cool() : Heat();
+        }
+
+        private IOperation Heat()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(ReheatingOperatorParameter.Value),
+                    base.Apply()
+                };
+        }
+
+        private IOperation Cool()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConnollyReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConnollyReheatingOperator.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConnollyReheatingOperator.cs	(revision 14743)
@@ -0,0 +1,196 @@
+﻿using HeuristicLab.Operators;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Analysis;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("ConnollyReheatingOperator", "Reheats the temperature only once after N consecutive solutions are rejected. It reheats to the temperature where the best solutions was found and the temperature stays there.")]
+    [StorableClass]
+    public class ConnollyReheatingOperator : SingleSuccessorOperator, IReheatingOperator
+    {
+        #region Strings
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string MaximumIterationsName = "MaximumIterations";
+
+        private const string ThresholdName = "Threshold";
+        private const string IdealTemperatureName = "IdealTemperature";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string QualityName = "Quality";
+        private const string CoolingName = "Cooling";
+        private const string ResultsName = "Results";
+
+        private const string BestQualityName = "BestQuality";
+        private const string TemperatureChartName = "Temperature Chart";
+        private const string QualitiesName = "Qualities";
+        private const string OptimalTemperatureName = "Optimal Temperature";
+
+        #endregion
+        #region Parameters
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> EndTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public ILookupParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
+        }
+        public ILookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        private ValueParameter<IntValue> ThresholdParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[ThresholdName]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<ItemList<BoolValue>> AcceptanceMemoryParameter
+        {
+            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
+        }
+        public ILookupParameter<BoolValue> CoolingParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[CoolingName]; }
+        }
+
+        #endregion
+
+        public ConnollyReheatingOperator() : base()
+        {
+            #region Create parameters
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new LookupParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
+            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled or heated."));
+            Parameters.Add(new LookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
+            Parameters.Add(new LookupParameter<BoolValue>(IsAcceptedName, "Whether the move was accepted or not."));
+            Parameters.Add(new LookupParameter<ItemList<BoolValue>>(AcceptanceMemoryName, "Memorizes the last N acceptance decisions."));
+            Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive solutions have to be rejected to trigger the reheat.", new IntValue(10)));
+            Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
+            #endregion
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected ConnollyReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected ConnollyReheatingOperator(ConnollyReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ConnollyReheatingOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+        }
+
+        public override IOperation Apply()
+        {
+            var cooling = CoolingParameter.ActualValue.Value;
+
+            if(cooling)
+            {
+                var acceptances = AcceptanceMemoryParameter.ActualValue;
+                acceptances.Add(IsAcceptedParameter.ActualValue);
+
+                if (acceptances.Count > ThresholdParameter.Value.Value) acceptances.RemoveAt(0);
+                var stopCooling = acceptances.Count == ThresholdParameter.Value.Value && !acceptances.Any(x => x.Value);
+
+                if(stopCooling)
+                {
+                    CoolingParameter.ActualValue.Value = false;
+                    return ReheatToIdealTemperature();
+                }else
+                {
+                    return Cool();
+                }
+            }
+            else
+            {
+                return KeepTemperature();
+            }
+        }
+
+        private IOperation ReheatToIdealTemperature()
+        {
+            var algorithm = ExecutionContext.Parent.Parent.Parent;
+            var results = (ResultCollection)algorithm.Scope.Variables[ResultsName].Value;
+            var bestQualitySoFar = (DoubleValue)results[BestQualityName].Value;
+            var temperatures = (DataTable)results[TemperatureChartName].Value;
+            var qualities = (DataTable)results[QualitiesName].Value;
+            var bestQualities = qualities.Rows[BestQualityName];
+            var indexOfBestQuality = bestQualities.Values.IndexOf(bestQualitySoFar.Value);
+            var bestTemperature = temperatures.Rows[TemperatureName].Values[indexOfBestQuality];
+
+            TemperatureParameter.ActualValue.Value = bestTemperature;
+
+            if (!results.ContainsKey(OptimalTemperatureName))
+            {
+                results.Add(new Result(OptimalTemperatureName, new DoubleValue(bestTemperature)));
+            }
+            else
+            {
+                results[OptimalTemperatureName].Value = new DoubleValue(bestTemperature);
+            }
+            return base.Apply();
+        }
+
+        private IOperation Cool()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+
+        private IOperation KeepTemperature()
+        {
+            return base.Apply();
+        }
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionReheatingOperator.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionReheatingOperator.cs	(revision 14743)
@@ -0,0 +1,157 @@
+﻿using HeuristicLab.Operators;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Analysis;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("ConsecutiveRejectionReheatingOperator", "The operator reheats the temperature by X when N consecutive solutions are rejected.")]
+    [StorableClass]
+    public class ConsecutiveRejectionReheatingOperator : SingleSuccessorOperator, IReheatingOperator
+    {
+        #region Strings
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string MaximumIterationsName = "MaximumIterations";
+
+        private const string ThresholdName = "Threshold";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string AmountName = "Amount";
+
+
+        #endregion
+
+        #region Parameters
+        private ValueParameter<DoubleValue> AmountParameter
+        {
+            get { return (ValueParameter<DoubleValue>)Parameters[AmountName]; }
+        }
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> EndTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public ILookupParameter<IOperator> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        }
+        public ILookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        private ValueParameter<IntValue> ThresholdParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[ThresholdName]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<ItemList<BoolValue>> AcceptanceMemoryParameter
+        {
+            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
+        }
+
+        #endregion
+
+        public ConsecutiveRejectionReheatingOperator() : base()
+        {
+            #region Create parameters
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new LookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling should occur."));
+            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled."));
+            Parameters.Add(new LookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
+            Parameters.Add(new LookupParameter<BoolValue>(IsAcceptedName, "Whether the move was accepted or not."));
+            Parameters.Add(new LookupParameter<ItemList<BoolValue>>(AcceptanceMemoryName, "Memorizes the last N acceptance decisions."));
+            Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive rejected solutions must occur to trigger a reheat.", new IntValue(10)));
+            Parameters.Add(new ValueParameter<DoubleValue>(AmountName, "The amount the temperature gets increased with every reheat.", new DoubleValue(20d)));
+            
+            #endregion
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected ConsecutiveRejectionReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected ConsecutiveRejectionReheatingOperator(ConsecutiveRejectionReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ConsecutiveRejectionReheatingOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+        }
+
+        public override IOperation Apply()
+        {
+            var acceptances = AcceptanceMemoryParameter.ActualValue;
+
+            acceptances.Add(IsAcceptedParameter.ActualValue);
+
+            if (acceptances.Count > ThresholdParameter.Value.Value) acceptances.RemoveAt(0);
+
+            var heating = acceptances.Count == ThresholdParameter.Value.Value && !acceptances.Any(x => x.Value);
+
+            return heating ? Heat() : Cool();
+        }
+
+        private IOperation Heat()
+        {
+            AcceptanceMemoryParameter.ActualValue.Clear();
+            TemperatureParameter.ActualValue.Value += AmountParameter.Value.Value;
+            TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+            StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+            return base.Apply();
+        }
+
+        private IOperation Cool()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs	(revision 14743)
@@ -0,0 +1,182 @@
+﻿using HeuristicLab.Operators;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Analysis;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("ConsecutiveRejectionTemperatureResetOperator", "The operator resets the temperature to X when N consecutive solutions are rejected. X is calculated by BaseResetTemperature * (MultiplyWithEachReheat to the power of the current number of reheats).")]
+    [StorableClass]
+    public class ConsecutiveRejectionTemperatureResetOperator : SingleSuccessorOperator, IReheatingOperator
+    {
+        #region Strings
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string MaximumIterationsName = "MaximumIterations";
+
+        private const string ThresholdName = "Threshold";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string BaseResetTemperatureName = "BaseResetTemperature";
+        private const string MultiplyWithEachReheatName = "MultiplyWithEachReheat";
+        private const string ReheatCountName = "ReheatCount";
+        private const string MaximumNumberOfReheatsName = "MaximumNumberOfReheats";
+        #endregion
+
+        #region Parameters
+        private ValueParameter<DoubleValue> BaseResetTemperatureParameter
+        {
+            get { return (ValueParameter<DoubleValue>)Parameters[BaseResetTemperatureName]; }
+        }
+        private ValueParameter<DoubleValue> MultiplyWithEachReheatParameter
+        {
+            get { return (ValueParameter<DoubleValue>)Parameters[MultiplyWithEachReheatName]; }
+        }
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> EndTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public ILookupParameter<IOperator> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        }
+        public ILookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        private ValueParameter<IntValue> ThresholdParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[ThresholdName]; }
+        }
+        private ValueParameter<IntValue> MaxNumberOfReheatsParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[MaximumNumberOfReheatsName]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<ItemList<BoolValue>> AcceptanceMemoryParameter
+        {
+            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
+        }
+        public ILookupParameter<IntValue> ReheatCountParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[ReheatCountName]; }
+        }
+        #endregion
+
+        public ConsecutiveRejectionTemperatureResetOperator() : base()
+        {
+            #region Create parameters
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new LookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling should occur."));
+            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled."));
+            Parameters.Add(new LookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
+            Parameters.Add(new LookupParameter<BoolValue>(IsAcceptedName, "Whether the move was accepted or not."));
+            Parameters.Add(new LookupParameter<ItemList<BoolValue>>(AcceptanceMemoryName, "Memorizes the last N acceptance decisions."));
+            Parameters.Add(new LookupParameter<IntValue>(ReheatCountName, "The number of reheats."));
+            Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive rejected solutions must occur to trigger a reheat.", new IntValue(10)));
+            Parameters.Add(new ValueParameter<IntValue>(MaximumNumberOfReheatsName, "The maximum number of reheats which can be triggered", new IntValue(10)));
+            Parameters.Add(new ValueParameter<DoubleValue>(BaseResetTemperatureName, "The base reset temperature.", new DoubleValue(100d)));
+            Parameters.Add(new ValueParameter<DoubleValue>(MultiplyWithEachReheatName, "The amount the last reset temperature is multiplied with each reheat.", new DoubleValue(1d)));
+
+            #endregion
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected ConsecutiveRejectionTemperatureResetOperator(bool deserializing) : base(deserializing) { }
+        protected ConsecutiveRejectionTemperatureResetOperator(ConsecutiveRejectionTemperatureResetOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ConsecutiveRejectionTemperatureResetOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+        }
+
+        public override IOperation Apply()
+        {
+            var acceptances = AcceptanceMemoryParameter.ActualValue;
+
+            acceptances.Add(IsAcceptedParameter.ActualValue);
+
+            if (acceptances.Count > ThresholdParameter.Value.Value) acceptances.RemoveAt(0);
+
+            var heating = acceptances.Count == ThresholdParameter.Value.Value && !acceptances.Any(x => x.Value) && !MaxNumberOfReheatsReached();
+
+            return heating ? Heat() : Cool();
+        }
+
+        private bool MaxNumberOfReheatsReached()
+        {
+            return ReheatCountParameter.ActualValue.Value >= MaxNumberOfReheatsParameter.Value.Value;
+        }
+
+        private IOperation Heat()
+        {
+            ReheatCountParameter.ActualValue.Value++;
+
+            AcceptanceMemoryParameter.ActualValue.Clear();
+
+            var temperature = Math.Max(BaseResetTemperatureParameter.Value.Value * Math.Pow(MultiplyWithEachReheatParameter.Value.Value, ReheatCountParameter.ActualValue.Value), TemperatureParameter.ActualValue.Value);
+
+            TemperatureParameter.ActualValue.Value = temperature;
+            TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+            StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+            return base.Apply();
+        }
+
+        private IOperation Cool()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj	(revision 14743)
@@ -0,0 +1,235 @@
+﻿<?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="AcceptanceRatioReheatingOperator.cs" />
+    <Compile Include="ConnollyReheatingOperator.cs" />
+    <Compile Include="ConsecutiveRejectionReheatingOperator.cs" />
+    <Compile Include="NoReheatingOperator.cs" />
+    <Compile Include="IReheatingOperator.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="SimulatedAnnealingImprovementOperator.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SimulatedAnnealing.cs" />
+    <Compile Include="SimulatedAnnealingMainLoop.cs" />
+    <Compile Include="TemperatureController.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.4/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.user
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.user	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.user	(revision 14743)
@@ -0,0 +1,6 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectView>ShowAllFiles</ProjectView>
+  </PropertyGroup>
+</Project>
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/HeuristicLab.Algorithms.SimulatedAnnealing-3.4.csproj
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/HeuristicLab.Algorithms.SimulatedAnnealing-3.4.csproj	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/HeuristicLab.Algorithms.SimulatedAnnealing-3.4.csproj	(revision 14743)
@@ -0,0 +1,236 @@
+﻿<?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.4</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="AcceptanceRatioReheatingOperator.cs" />
+    <Compile Include="ConnollyReheatingOperator.cs" />
+    <Compile Include="ConsecutiveRejectionTemperatureResetOperator.cs" />
+    <Compile Include="ConsecutiveRejectionReheatingOperator.cs" />
+    <Compile Include="NoReheatingOperator.cs" />
+    <Compile Include="IReheatingOperator.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="SimulatedAnnealingImprovementOperator.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SimulatedAnnealing.cs" />
+    <Compile Include="SimulatedAnnealingMainLoop.cs" />
+    <Compile Include="TemperatureController.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.4/IReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/IReheatingOperator.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/IReheatingOperator.cs	(revision 14743)
@@ -0,0 +1,15 @@
+﻿using HeuristicLab.Core;
+using HeuristicLab.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    public interface IReheatingOperator : IOperator
+    {
+        void Parameterize();
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/NoReheatingOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/NoReheatingOperator.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/NoReheatingOperator.cs	(revision 14743)
@@ -0,0 +1,111 @@
+﻿using HeuristicLab.Operators;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Analysis;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("-", "No reheats are performed.")]
+    [StorableClass]
+    public class NoReheatingOperator : SingleSuccessorOperator, IReheatingOperator
+    {
+        #region Strings
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string MaximumIterationsName = "MaximumIterations";
+
+
+        #endregion
+        #region Parameters
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> EndTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public ILookupParameter<IOperator> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        }
+        public ILookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+
+        #endregion
+
+        public NoReheatingOperator() : base()
+        {
+            #region Create parameters
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
+            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled or heated."));
+            Parameters.Add(new LookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
+            Parameters.Add(new LookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            #endregion
+
+            Parameterize();
+        }
+
+        [StorableConstructor]
+        protected NoReheatingOperator(bool deserializing) : base(deserializing) { }
+        protected NoReheatingOperator(NoReheatingOperator original, Cloner cloner) : base(original, cloner) { }
+
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new NoReheatingOperator(this, cloner);
+        }
+
+        public void Parameterize()
+        {
+        }
+
+        public override IOperation Apply()
+        {
+            TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
+            StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
+            EndTemperatureParameter.ActualValue.Value = LowerTemperatureParameter.ActualValue.Value;
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Plugin.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Plugin.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Plugin.cs	(revision 14743)
@@ -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.4.14.14195")]
+  [PluginFile("HeuristicLab.Algorithms.SimulatedAnnealing-3.4.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.4/Plugin.cs.frame
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Plugin.cs.frame	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Plugin.cs.frame	(revision 14743)
@@ -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.4.14.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.SimulatedAnnealing-3.4.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.4/Properties/AssemblyInfo.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Properties/AssemblyInfo.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Properties/AssemblyInfo.cs	(revision 14743)
@@ -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.4.0.0")]
+[assembly: AssemblyFileVersion("3.4.14.14195")]
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Properties/AssemblyInfo.cs.frame	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/Properties/AssemblyInfo.cs.frame	(revision 14743)
@@ -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.4.0.0")]
+[assembly: AssemblyFileVersion("3.4.14.$WCREV$")]
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealing.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealing.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealing.cs	(revision 14743)
@@ -0,0 +1,622 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("Simulated Annealing", "An advanced simulated annealing algorithm.")]
+    [Creatable("Algorithms")]
+    [StorableClass]
+    public sealed class SimulatedAnnealing : HeuristicOptimizationEngineAlgorithm, IStorableContent
+    {
+        #region Strings
+        private const string SeedName = "Seed";
+        private const string SetSeedRandomlyName = "SetSeedRandomly";
+        private const string MoveGeneratorName = "MoveGenerator";
+        private const string MoveEvaluatorName = "MoveEvaluator";
+        private const string MoveMakerName = "MoveMaker";
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string ReheatingOperatorName = "ReheatingOperator";
+        private const string MaximumIterationsName = "MaximumIterations";
+        private const string InitialTemperatureName = "InitialTemperature";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string AnalyzerName = "Analyzer";
+        private const string RandomName = "Random";
+        private const string EvaluatedMovesName = "EvaluatedMoves";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string CoolingName = "Cooling";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string ResultsName = "Results";
+        private const string TemperatureChartName = "Temperature Chart";
+        private const string TemperatureAnalyzerName = "Temperature Analyzer";
+        #endregion
+
+        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[SeedName]; }
+        }
+        private ValueParameter<BoolValue> SetSeedRandomlyParameter
+        {
+            get { return (ValueParameter<BoolValue>)Parameters[SetSeedRandomlyName]; }
+        }
+        public IConstrainedValueParameter<IMultiMoveGenerator> MoveGeneratorParameter
+        {
+            get { return (IConstrainedValueParameter<IMultiMoveGenerator>)Parameters[MoveGeneratorName]; }
+        }
+        public IConstrainedValueParameter<IMoveMaker> MoveMakerParameter
+        {
+            get { return (IConstrainedValueParameter<IMoveMaker>)Parameters[MoveMakerName]; }
+        }
+        public IConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter
+        {
+            get { return (IConstrainedValueParameter<ISingleObjectiveMoveEvaluator>)Parameters[MoveEvaluatorName]; }
+        }
+        public IConstrainedValueParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter
+        {
+            get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
+        }
+
+        public IConstrainedValueParameter<IReheatingOperator> ReheatingOperatorParameter
+        {
+            get { return (IConstrainedValueParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
+        }
+
+        private ValueParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (ValueParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        private ValueParameter<DoubleValue> InitialTemperatureParameter
+        {
+            get { return (ValueParameter<DoubleValue>)Parameters[InitialTemperatureName]; }
+        }
+        private ValueParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (ValueParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        private ValueParameter<MultiAnalyzer> AnalyzerParameter
+        {
+            get { return (ValueParameter<MultiAnalyzer>)Parameters[AnalyzerName]; }
+        }
+        #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 IReheatingOperator ReheatingOperator
+        {
+            get { return ReheatingOperatorParameter.Value; }
+            set { ReheatingOperatorParameter.Value = value; }
+        }
+
+        public IntValue MaximumIterations
+        {
+            get { return MaximumIterationsParameter.Value; }
+            set { MaximumIterationsParameter.Value = value; }
+        }
+        public DoubleValue InitialTemperature
+        {
+            get { return InitialTemperatureParameter.Value; }
+            set { InitialTemperatureParameter.Value = value; }
+        }
+        public DoubleValue LowerTemperature
+        {
+            get { return LowerTemperatureParameter.Value; }
+            set { LowerTemperatureParameter.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 OperatorGraph.Iterate().OfType<SimulatedAnnealingMainLoop>().First(); }
+        }
+        #endregion
+
+        [StorableConstructor]
+        private SimulatedAnnealing(bool deserializing) : base(deserializing) { }
+        private SimulatedAnnealing(SimulatedAnnealing original, Cloner cloner)
+          : base(original, cloner)
+        {
+            RegisterEventHandlers();
+        }
+        public SimulatedAnnealing()
+          : base()
+        {
+            Parameters.Add(new ValueParameter<IntValue>(SeedName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+            Parameters.Add(new ValueParameter<BoolValue>(SetSeedRandomlyName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+            Parameters.Add(new ConstrainedValueParameter<IMultiMoveGenerator>(MoveGeneratorName, "The operator used to generate moves to the neighborhood of the current solution."));
+            Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>(MoveEvaluatorName, "The operator used to evaluate a move."));
+            Parameters.Add(new ConstrainedValueParameter<IMoveMaker>(MoveMakerName, "The operator used to perform a move."));
+            Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator used to cool the temperature."));
+            Parameters.Add(new ConstrainedValueParameter<IReheatingOperator>(ReheatingOperatorName, "The operator used to reheat the temperature, if necessary."));
+            Parameters.Add(new ValueParameter<IntValue>(MaximumIterationsName, "The maximum number of generations which should be processed.", new IntValue(10000)));
+            Parameters.Add(new ValueParameter<DoubleValue>(InitialTemperatureName, "The initial temperature.", new DoubleValue(100)));
+            Parameters.Add(new ValueParameter<DoubleValue>(LowerTemperatureName, "The lower bound for the temperature.", new DoubleValue(1e-6)));
+            Parameters.Add(new ValueParameter<MultiAnalyzer>(AnalyzerName, "The operator used to analyze each iteration.", new MultiAnalyzer()));
+
+            var randomCreator = new RandomCreator();
+            var solutionsCreator = new SolutionsCreator();
+            var variableCreator = new VariableCreator();
+            var startTemperatureAssigner = new Assigner();
+            var endTemperatureAssigner = new Assigner();
+            var temperatureAssigner = new Assigner();
+            var resultsCollector = new ResultsCollector();
+            var mainLoop = new SimulatedAnnealingMainLoop();
+            OperatorGraph.InitialOperator = randomCreator;
+
+            randomCreator.RandomParameter.ActualName = RandomName;
+            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 Variables";
+            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(EvaluatedMovesName, new IntValue()));
+            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(IterationsName, new IntValue(0)));
+            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(TemperatureStartIndexName, new IntValue(0)));
+            variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>(CoolingName, new BoolValue(true)));
+            variableCreator.Successor = startTemperatureAssigner;
+
+            startTemperatureAssigner.Name = "Assign Start Temperature";
+            startTemperatureAssigner.LeftSideParameter.ActualName = StartTemperatureName;
+            startTemperatureAssigner.RightSideParameter.ActualName = InitialTemperatureParameter.Name;
+            startTemperatureAssigner.Successor = endTemperatureAssigner;
+
+            endTemperatureAssigner.Name = "Assign End Temperature";
+            endTemperatureAssigner.LeftSideParameter.ActualName = EndTemperatureName;
+            endTemperatureAssigner.RightSideParameter.ActualName = LowerTemperatureParameter.Name;
+            endTemperatureAssigner.Successor = temperatureAssigner;
+
+            temperatureAssigner.Name = "Initialize Temperature";
+            temperatureAssigner.LeftSideParameter.ActualName = TemperatureName;
+            temperatureAssigner.RightSideParameter.ActualName = StartTemperatureName;
+            temperatureAssigner.Successor = resultsCollector;
+
+            resultsCollector.CopyValue = new BoolValue(false);
+            resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(EvaluatedMovesName, null));
+            resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(IterationsName, null));
+            resultsCollector.ResultsParameter.ActualName = ResultsName;
+            resultsCollector.Successor = mainLoop;
+
+            mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
+            mainLoop.AnnealingOperatorParameter.ActualName = AnnealingOperatorParameter.Name;
+            mainLoop.CoolingParameter.ActualName = CoolingName;
+            mainLoop.EndTemperatureParameter.ActualName = EndTemperatureName;
+            mainLoop.EvaluatedMovesParameter.ActualName = EvaluatedMovesName;
+
+            mainLoop.IterationsParameter.ActualName = IterationsName;
+            mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
+            mainLoop.MoveEvaluatorParameter.ActualName = MoveEvaluatorParameter.Name;
+            mainLoop.MoveGeneratorParameter.ActualName = MoveGeneratorParameter.Name;
+            mainLoop.MoveMakerParameter.ActualName = MoveMakerParameter.Name;
+            mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+            mainLoop.ResultsParameter.ActualName = ResultsName;
+            mainLoop.StartTemperatureParameter.ActualName = StartTemperatureName;
+            mainLoop.TemperatureStartIndexParameter.ActualName = TemperatureStartIndexName;
+            mainLoop.TemperatureParameter.ActualName = TemperatureName;
+
+            foreach (var op in ApplicationManager.Manager.GetInstances<IReheatingOperator>().OrderBy(x => x.Name))
+            {
+               
+                ReheatingOperatorParameter.ValidValues.Add(op);
+            }
+
+            foreach (var op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
+            {
+                AnnealingOperatorParameter.ValidValues.Add(op);
+            }
+
+            UpdateAnalyzers();
+
+            Parameterize();
+
+            RegisterEventHandlers();
+        }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new SimulatedAnnealing(this, cloner);
+        }
+
+        [StorableHook(HookType.AfterDeserialization)]
+        private void AfterDeserialization()
+        {
+            RegisterEventHandlers();
+        }
+
+        private void RegisterEventHandlers()
+        {
+            if (Problem != null)
+            {
+                Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+                foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
+                {
+                    op.MoveQualityParameter.ActualNameChanged += MoveEvaluator_MoveQualityParameter_ActualNameChanged;
+                }
+            }
+            MoveGeneratorParameter.ValueChanged += MoveGeneratorParameter_ValueChanged;
+            MoveEvaluatorParameter.ValueChanged += MoveEvaluatorParameter_ValueChanged;
+        }
+
+        public override void Prepare()
+        {
+            if (Problem != null && MoveGenerator != null && MoveMaker != null && MoveEvaluator != null)
+                base.Prepare();
+        }
+
+        #region Events
+        protected override void OnProblemChanged()
+        {
+            foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
+            {
+                op.MoveQualityParameter.ActualNameChanged += MoveEvaluator_MoveQualityParameter_ActualNameChanged;
+            }
+            UpdateMoveGenerator();
+            UpdateMoveOperators();
+            UpdateAnalyzers();
+            Parameterize();
+            Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+            base.OnProblemChanged();
+        }
+        protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e)
+        {
+            Parameterize();
+            base.Problem_SolutionCreatorChanged(sender, e);
+        }
+        protected override void Problem_EvaluatorChanged(object sender, EventArgs e)
+        {
+            Parameterize();
+            Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+            base.Problem_EvaluatorChanged(sender, e);
+        }
+        protected override void Problem_OperatorsChanged(object sender, EventArgs e)
+        {
+            foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
+            {
+                op.MoveQualityParameter.ActualNameChanged -= MoveEvaluator_MoveQualityParameter_ActualNameChanged;
+                op.MoveQualityParameter.ActualNameChanged += MoveEvaluator_MoveQualityParameter_ActualNameChanged;
+            }
+            UpdateMoveGenerator();
+            UpdateMoveOperators();
+            UpdateAnalyzers();
+            Parameterize();
+            base.Problem_OperatorsChanged(sender, e);
+        }
+        private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e)
+        {
+            Parameterize();
+        }
+        private void MoveGeneratorParameter_ValueChanged(object sender, EventArgs e)
+        {
+            UpdateMoveOperators();
+        }
+        private void MoveEvaluatorParameter_ValueChanged(object sender, EventArgs e)
+        {
+            Parameterize();
+        }
+        private void MoveEvaluator_MoveQualityParameter_ActualNameChanged(object sender, EventArgs e)
+        {
+            if (sender == MoveEvaluator) Parameterize();
+        }
+        #endregion
+
+        #region Helpers
+
+        private void UpdateMoveGenerator()
+        {
+            var oldMoveGenerator = MoveGenerator;
+            var defaultMoveGenerator = Problem.Operators.OfType<IMultiMoveGenerator>().FirstOrDefault();
+
+            MoveGeneratorParameter.ValidValues.Clear();
+
+            if (Problem != null)
+            {
+                foreach (var generator in Problem.Operators.OfType<IMultiMoveGenerator>().OrderBy(x => x.Name))
+                    MoveGeneratorParameter.ValidValues.Add(generator);
+            }
+
+            if (oldMoveGenerator != null)
+            {
+                var newMoveGenerator = MoveGeneratorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveGenerator.GetType());
+                if (newMoveGenerator != null) MoveGenerator = newMoveGenerator;
+                else oldMoveGenerator = null;
+            }
+            if (oldMoveGenerator == null && defaultMoveGenerator != null)
+                MoveGenerator = defaultMoveGenerator;
+
+            UpdateMoveOperators();
+        }
+
+        private void UpdateMoveOperators()
+        {
+            var oldMoveMaker = MoveMaker;
+            var oldMoveEvaluator = MoveEvaluator;
+
+            MoveMakerParameter.ValidValues.Clear();
+            MoveEvaluatorParameter.ValidValues.Clear();
+
+            if (MoveGenerator != null)
+            {
+                var moveTypes = MoveGenerator.GetType().GetInterfaces().Where(x => typeof(IMoveOperator).IsAssignableFrom(x)).ToList();
+                foreach (var 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();
+                var defaultMoveMaker = operators.OfType<IMoveMaker>().FirstOrDefault();
+                var defaultMoveEvaluator = operators.OfType<ISingleObjectiveMoveEvaluator>().FirstOrDefault();
+
+                foreach (var moveMaker in operators.OfType<IMoveMaker>().OrderBy(op => op.Name))
+                    MoveMakerParameter.ValidValues.Add(moveMaker);
+
+                foreach (var moveEvaluator in operators.OfType<ISingleObjectiveMoveEvaluator>().OrderBy(op => op.Name))
+                    MoveEvaluatorParameter.ValidValues.Add(moveEvaluator);
+
+                if (oldMoveMaker != null)
+                {
+                    var 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)
+                {
+                    var 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 UpdateAnalyzers()
+        {
+            Analyzer.Operators.Clear();
+            if (Problem != null)
+            {
+                foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>())
+                {
+                    foreach (var param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
+                        param.Depth = 0;
+                    Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+                }
+            }
+            var qualityAnalyzer = new QualityAnalyzer();
+            var temperatureAnalyzer = new SingleValueAnalyzer { Name = TemperatureAnalyzerName };
+            Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+            Analyzer.Operators.Add(temperatureAnalyzer, temperatureAnalyzer.EnabledByDefault);
+        }
+
+        private void Parameterize()
+        {
+
+            #region IStochasticOperator
+            if (Problem != null)
+            {
+                foreach (var op in Problem.Operators.OfType<IStochasticOperator>())
+                {
+                    op.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+                    op.RandomParameter.Hidden = true;
+                }
+            }
+            #endregion
+
+            #region IIterationBasedOperator
+            if (Problem != null)
+            {
+                foreach (var op in Problem.Operators.OfType<IIterationBasedOperator>())
+                {
+                    op.IterationsParameter.ActualName = IterationsName;
+                    op.IterationsParameter.Hidden = true;
+                    op.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
+                    op.MaximumIterationsParameter.Hidden = true;
+                }
+            }
+            #endregion
+
+            #region Analyzers
+
+            foreach (var qualityAnalyzer in Analyzer.Operators.OfType<QualityAnalyzer>())
+            {
+                qualityAnalyzer.ResultsParameter.ActualName = ResultsName;
+                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;
+                }
+            }
+
+            var temperatureAnalyzer = Analyzer.Operators.OfType<SingleValueAnalyzer>().FirstOrDefault(x => x.Name == TemperatureAnalyzerName);
+            if (temperatureAnalyzer != null)
+            {
+                temperatureAnalyzer.ResultsParameter.ActualName = ResultsName;
+                temperatureAnalyzer.ResultsParameter.Hidden = true;
+                temperatureAnalyzer.ValueParameter.ActualName = TemperatureName;
+                temperatureAnalyzer.ValueParameter.Hidden = true;
+                temperatureAnalyzer.ValuesParameter.ActualName = TemperatureChartName;
+                temperatureAnalyzer.ValuesParameter.Hidden = true;
+            }
+
+            #endregion
+
+            #region SolutionCreator
+            if (Problem != null)
+            {
+                SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+                SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+            }
+            #endregion
+
+            #region Annealing/Reheating Operators
+            foreach (var op in AnnealingOperatorParameter.ValidValues)
+            {
+                op.IndexParameter.ActualName = IterationsName;
+                op.IndexParameter.Hidden = true;
+                op.StartIndexParameter.Value = null;
+                op.StartIndexParameter.ActualName = TemperatureStartIndexName;
+                op.EndIndexParameter.ActualName = MaximumIterationsParameter.Name;
+                op.ValueParameter.ActualName = TemperatureName;
+                op.ValueParameter.Hidden = true;
+                op.StartValueParameter.ActualName = StartTemperatureName;
+                op.StartValueParameter.Hidden = true;
+                op.EndValueParameter.ActualName = LowerTemperatureParameter.Name;
+                op.EndValueParameter.Hidden = true;
+            }
+            foreach (var op in ReheatingOperatorParameter.ValidValues)
+            {
+                op.Parameterize();
+            }
+            #endregion
+
+            #region Move Operators
+            if (Problem != null)
+            {
+                foreach (var op in Problem.Operators.OfType<IMultiMoveGenerator>())
+                {
+                    op.SampleSizeParameter.Value = new IntValue(1);
+                    op.SampleSizeParameter.Hidden = true;
+                }
+                foreach (var 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;
+                    }
+                }
+                foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
+                {
+                    op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+                    op.QualityParameter.Hidden = true;
+                }
+            }
+            #endregion
+
+            #region MainLoop
+            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;
+            }
+            #endregion
+
+        }
+        #endregion
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingImprovementOperator.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingImprovementOperator.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingImprovementOperator.cs	(revision 14743)
@@ -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.4/SimulatedAnnealingMainLoop.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingMainLoop.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingMainLoop.cs	(revision 14743)
@@ -0,0 +1,305 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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
+{
+    [Item("SimulatedAnnealingMainLoop", "An operator which represents the main loop of a simulated annealing algorithm.")]
+    [StorableClass]
+    public sealed class SimulatedAnnealingMainLoop : AlgorithmOperator
+    {
+        #region Strings
+        private const string MoveGeneratorName = "MoveGenerator";
+        private const string MoveEvaluatorName = "MoveEvaluator";
+        private const string MoveMakerName = "MoveMaker";
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string ReheatingOperatorName = "ReheatingOperator";
+        private const string MaximumIterationsName = "MaximumIterations";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string AnalyzerName = "Analyzer";
+        private const string RandomName = "Random";
+        private const string EvaluatedMovesName = "EvaluatedMoves";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string CoolingName = "Cooling";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string ResultsName = "Results";
+        private const string MaximizationName = "Maximization";
+        private const string QualityName = "Quality";
+        private const string BestKnownQualityName = "BestKnownQuality";
+        private const string MoveQualityName = "MoveQuality";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string TerminateName = "Terminate";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string ReheatCountName = "ReheatCount";
+        #endregion
+
+        #region Parameter properties
+        public IValueLookupParameter<IRandom> RandomParameter
+        {
+            get { return (IValueLookupParameter<IRandom>)Parameters[RandomName]; }
+        }
+        public IValueLookupParameter<BoolValue> MaximizationParameter
+        {
+            get { return (IValueLookupParameter<BoolValue>)Parameters[MaximizationName]; }
+        }
+        public ILookupParameter<DoubleValue> QualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[QualityName]; }
+        }
+        public IValueLookupParameter<DoubleValue> BestKnownQualityParameter
+        {
+            get { return (IValueLookupParameter<DoubleValue>)Parameters[BestKnownQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> MoveQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public IValueLookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public IValueLookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (IValueLookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        public IValueLookupParameter<IOperator> MoveGeneratorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[MoveGeneratorName]; }
+        }
+        public IValueLookupParameter<IOperator> MoveEvaluatorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[MoveEvaluatorName]; }
+        }
+        public IValueLookupParameter<IOperator> MoveMakerParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[MoveMakerName]; }
+        }
+        public IValueLookupParameter<IOperator> AnnealingOperatorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        }
+        public IValueLookupParameter<IOperator> ReheatingOperatorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[ReheatingOperatorName]; }
+        }
+        public IValueLookupParameter<IOperator> AnalyzerParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[AnalyzerName]; }
+        }
+        public IValueLookupParameter<VariableCollection> ResultsParameter
+        {
+            get { return (IValueLookupParameter<VariableCollection>)Parameters[ResultsName]; }
+        }
+        public ILookupParameter<IntValue> EvaluatedMovesParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[EvaluatedMovesName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> EndTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<BoolValue> CoolingParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[CoolingName]; }
+        }
+        #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>(RandomName, "A pseudo random number generator."));
+            Parameters.Add(new ValueLookupParameter<BoolValue>(MaximizationName, "True if the problem is a maximization problem, otherwise false."));
+            Parameters.Add(new LookupParameter<DoubleValue>(QualityName, "The value which represents the quality of a solution."));
+            Parameters.Add(new ValueLookupParameter<DoubleValue>(BestKnownQualityName, "The best known quality value found so far."));
+            Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
+
+            Parameters.Add(new ValueLookupParameter<IOperator>(MoveGeneratorName, "The operator that generates the moves."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(MoveEvaluatorName, "The operator that evaluates a move."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(MoveMakerName, "The operator that performs a move and updates the quality."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(ReheatingOperatorName, "The operator that reheats the temperature if necessary."));
+
+            Parameters.Add(new ValueLookupParameter<IOperator>(AnalyzerName, "The operator used to analyze each generation."));
+            Parameters.Add(new ValueLookupParameter<VariableCollection>(ResultsName, "The variable collection where results should be stored."));
+            Parameters.Add(new LookupParameter<IntValue>(EvaluatedMovesName, "The number of evaluated moves."));
+
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
+            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled or heated."));
+            #endregion
+
+            #region Create operators
+            var variableCreator = new VariableCreator();
+            var ssp1 = new SubScopesProcessor();
+            var analyzer1 = new Placeholder();
+            var ssp2 = new SubScopesProcessor();
+            var resultsCollector = new ResultsCollector();
+            var mainProcessor = new SubScopesProcessor();
+            var moveGenerator = new Placeholder();
+            var moveEvaluationProcessor = new SubScopesProcessor();
+            var moveEvaluator = new Placeholder();
+            var evaluatedMovesCounter = new IntCounter();
+            var qualityComparator = new ProbabilisticQualityComparator();
+            var acceptsQualityBranch = new ConditionalBranch();
+            var moveMaker = new Placeholder();
+            var temperatureController = new TemperatureController();
+            var subScopesRemover = new SubScopesRemover();
+            var iterationsCounter = new IntCounter();
+            var iterationsComparator = new Comparator();
+            var ssp3 = new SubScopesProcessor();
+            var analyzer2 = new Placeholder();
+            var iterationsTermination = new ConditionalBranch();
+
+            variableCreator.Name = "Initialize Memory";
+            variableCreator.CollectedValues.Add(new ValueParameter<ItemList<BoolValue>>(AcceptanceMemoryName, new ItemList<BoolValue>()));
+            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(ReheatCountName, new IntValue(0)));
+
+            analyzer1.Name = "Analyzer";
+            analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+            moveGenerator.Name = "Move generator";
+            moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
+
+            moveEvaluator.Name = "Move evaluator";
+            moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
+
+            evaluatedMovesCounter.Name = "EvaluatedMoves++";
+            evaluatedMovesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
+            evaluatedMovesCounter.Increment = new IntValue(1);
+
+            qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
+            qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
+            qualityComparator.ResultParameter.ActualName = IsAcceptedName;
+            qualityComparator.DampeningParameter.ActualName = TemperatureParameter.Name;
+
+            acceptsQualityBranch.ConditionParameter.ActualName = IsAcceptedName;
+
+            moveMaker.Name = "Move maker";
+            moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
+
+           
+
+            subScopesRemover.RemoveAllSubScopes = true;
+
+            iterationsCounter.Name = "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 = TerminateName;
+            iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
+
+            analyzer2.Name = "Analyzer (placeholder)";
+            analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+            iterationsTermination.Name = "Iterations termination condition";
+            iterationsTermination.ConditionParameter.ActualName = TerminateName;
+            #endregion
+
+            #region Create operator graph
+            OperatorGraph.InitialOperator = variableCreator;
+            variableCreator.Successor = ssp1;
+            ssp1.Operators.Add(analyzer1);
+            ssp1.Successor = ssp2;
+            analyzer1.Successor = null;
+            ssp2.Operators.Add(resultsCollector);
+            ssp2.Successor = mainProcessor;
+            resultsCollector.Successor = null;
+            mainProcessor.Operators.Add(moveGenerator);
+            mainProcessor.Successor = iterationsCounter;
+            moveGenerator.Successor = moveEvaluationProcessor;
+            moveEvaluationProcessor.Operators.Add(moveEvaluator);
+            moveEvaluationProcessor.Successor = evaluatedMovesCounter;
+            moveEvaluator.Successor = qualityComparator;
+            qualityComparator.Successor = acceptsQualityBranch;
+            acceptsQualityBranch.TrueBranch = moveMaker;
+            acceptsQualityBranch.FalseBranch = null;
+            acceptsQualityBranch.Successor = temperatureController;
+            moveMaker.Successor = null;
+            temperatureController.Successor = null;
+            evaluatedMovesCounter.Successor = subScopesRemover;
+            subScopesRemover.Successor = null;
+            iterationsCounter.Successor = iterationsComparator;
+            iterationsComparator.Successor = ssp3;
+            ssp3.Operators.Add(analyzer2);
+            ssp3.Successor = iterationsTermination;
+            iterationsTermination.TrueBranch = null;
+            iterationsTermination.FalseBranch = mainProcessor;
+            #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.4/TemperatureController.cs
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureController.cs	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureController.cs	(revision 14743)
@@ -0,0 +1,144 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.SimulatedAnnealing
+{
+    [Item("TemperatureController", "Decides based on information from the heatingoperator, whether to use cooling or heating and calls the appropriate operator.")]
+    [StorableClass]
+    public class TemperatureController : SingleSuccessorOperator
+    {
+        #region Strings
+        private const string ReheatingOperatorName = "ReheatingOperator";
+        private const string AnnealingOperatorName = "AnnealingOperator";
+        private const string MaximumIterationsName = "MaximumIterations";
+        private const string LowerTemperatureName = "LowerTemperature";
+        private const string IterationsName = "Iterations";
+        private const string TemperatureStartIndexName = "TemperatureStartIndex";
+        private const string CoolingName = "Cooling";
+        private const string StartTemperatureName = "StartTemperature";
+        private const string EndTemperatureName = "EndTemperature";
+        private const string TemperatureName = "Temperature";
+        private const string IsAcceptedName = "IsAccepted";
+        private const string AcceptanceMemoryName = "AcceptanceMemory";
+        private const string ReheatCountName = "ReheatCount";
+        #endregion
+
+        #region Parameter Properties
+        public ILookupParameter<DoubleValue> TemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
+        }
+        public IValueLookupParameter<DoubleValue> LowerTemperatureParameter
+        {
+            get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> StartTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
+        }
+        public ILookupParameter<DoubleValue> EndTemperatureParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
+        }
+        public ILookupParameter<IntValue> TemperatureStartIndexParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
+        }
+        public ILookupParameter<BoolValue> CoolingParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[CoolingName]; }
+        }
+        public ILookupParameter<IntValue> IterationsParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
+        }
+        public IValueLookupParameter<IntValue> MaximumIterationsParameter
+        {
+            get { return (IValueLookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
+        }
+        public IValueLookupParameter<IOperator> AnnealingOperatorParameter
+        {
+            get { return (IValueLookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        }
+        public IValueLookupParameter<IReheatingOperator> ReheatingOperatorParameter
+        {
+            get { return (IValueLookupParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
+        }
+        public ILookupParameter<BoolValue> IsAcceptedParameter
+        {
+            get { return (ILookupParameter<BoolValue>)Parameters[IsAcceptedName]; }
+        }
+        public ILookupParameter<ItemList<BoolValue>> AcceptanceMemoryParameter
+        {
+            get { return (ILookupParameter<ItemList<BoolValue>>)Parameters[AcceptanceMemoryName]; }
+        }
+        public ILookupParameter<IntValue> ReheatCountParameter
+        {
+            get { return (ILookupParameter<IntValue>)Parameters[ReheatCountName]; }
+        }
+        #endregion
+
+        [StorableConstructor]
+        protected TemperatureController(bool deserializing) : base(deserializing) { }
+        protected TemperatureController(TemperatureController original, Cloner cloner) : base(original, cloner) { }
+        public TemperatureController()
+          : base()
+        {
+            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
+            Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
+            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
+            Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
+            Parameters.Add(new ValueLookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new ValueLookupParameter<IReheatingOperator>(ReheatingOperatorName, "The operator that reheats the temperature if necessary."));
+            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
+            Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
+            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
+            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled or heated."));
+            Parameters.Add(new LookupParameter<BoolValue>(IsAcceptedName, "Whether the move was accepted or not."));
+            Parameters.Add(new LookupParameter<ItemList<BoolValue>>(AcceptanceMemoryName, "Memorizes the last N acceptance decisions."));
+            Parameters.Add(new LookupParameter<IntValue>(ReheatCountName, "The number of reheats."));
+        }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new TemperatureController(this, cloner);
+        }
+
+        public override IOperation Apply()
+        {
+            return new OperationCollection {
+                    ExecutionContext.CreateOperation(ReheatingOperatorParameter.ActualValue),
+                    base.Apply()
+                };
+        }
+    }
+}
Index: /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/obj/Release/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.FileListAbsolute.txt
===================================================================
--- /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/obj/Release/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.FileListAbsolute.txt	(revision 14743)
+++ /branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/obj/Release/HeuristicLab.Algorithms.SimulatedAnnealing-3.3.csproj.FileListAbsolute.txt	(revision 14743)
@@ -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
