source: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/ContinuousReheater.cs @ 14547

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;

namespace HeuristicLab.Algorithms.SimulatedAnnealing
{
    [Item("Continuous Reheater", "Reheats the temperature continuously, while the acceptance rate of solutions is under the threshold.")]
    [StorableClass]
    public class ContinuousReheater : SingleSuccessorOperator, ISimulatedAnnealingHeatingStrategy
    {
        #region Strings
        private const string UpperTemperatureName = "UpperTemperature";
        private const string ReheatingOperatorName = "ReheatingOperator";
        private const string ThresholdName = "Threshold";
        private const string MemorySizeName = "MemorySize";


        private const string IterationsName = "Iterations";
        private const string MaximumIterationsName = "MaximumIterations";
        private const string TemperatureStartIndexName = "TemperatureStartIndex";
        private const string StartTemperatureName = "StartTemperature";
        private const string EndTemperatureName = "EndTemperature";
        private const string TemperatureName = "Temperature";
        private const string CoolingName = "Cooling";
        private const string IsAcceptedName = "IsAccepted";
        private const string AcceptanceMemoryName = "AcceptanceMemory";


        #endregion
        #region Parameters
        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<IntValue> IterationsParameter
        {
            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
        }
        public IValueLookupParameter<IntValue> MaximumIterationsParameter
        {
            get { return (IValueLookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
        }
        public ILookupParameter<DoubleValue> TemperatureParameter
        {
            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
        }
        public ILookupParameter<DoubleValue> EndTemperatureParameter
        {
            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
        }
        public ILookupParameter<DoubleValue> StartTemperatureParameter
        {
            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
        }
        public ILookupParameter<IntValue> TemperatureStartIndexParameter
        {
            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
        }
        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
        #region Properties
        public DoubleValue UpperTemperature
        {
            get { return UpperTemperatureParameter.Value; }
            set { UpperTemperatureParameter.Value = value; }
        }
        public IDiscreteDoubleValueModifier ReheatingOperator
        {
            get { return ReheatingOperatorParameter.Value; }
            set { ReheatingOperatorParameter.Value = value; }
        }
        public DoubleRange AcceptanceThreshold
        {
            get { return ThresholdParameter.Value; }
            set { ThresholdParameter.Value = value; }
        }
        public IntValue AcceptanceMemorySize
        {
            get { return MemorySizeParameter.Value; }
            set { MemorySizeParameter.Value = value; }
        }
        #endregion

        public ContinuousReheater() : base()
        {
            #region Create parameters
            Parameters.Add(new ValueParameter<DoubleValue>(UpperTemperatureName, "The upper bound of the temperature.", new DoubleValue(100d)));
            Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>(ReheatingOperatorName, "Reheating operator."));
            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.1, 0.05)));
            Parameters.Add(new ValueParameter<IntValue>(MemorySizeName, "The maximum size of the acceptance memory.", new IntValue(100)));

            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
            Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
            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."));
            #endregion

            foreach (var op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
            {
                ReheatingOperatorParameter.ValidValues.Add(op);
            }

            Parameterize();
        }

        [StorableConstructor]
        protected ContinuousReheater(bool deserializing) : base(deserializing) { }
        protected ContinuousReheater(ContinuousReheater original, Cloner cloner) : base(original, cloner) { }


        public override IDeepCloneable Clone(Cloner cloner)
        {
            return new ContinuousReheater(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 = EndTemperatureName;
                op.EndValueParameter.Hidden = true;
            }
        }

        public bool ShouldReheat(bool cooling, ItemList<BoolValue> acceptances) {

            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)
            {
                return false;
            }
            else if (cooling && ratio <= ratioStart)
            {  // temperature is cooled, but should be heated
                return true;
            }
            return !cooling;
        }
        public override IOperation Apply()
        {
            var iterations = IterationsParameter.ActualValue.Value;
            TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, iterations - 1);
            StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
            EndTemperatureParameter.ActualValue.Value = UpperTemperatureParameter.Value.Value;

            return new OperationCollection {
                   ExecutionContext.CreateOperation(ReheatingOperatorParameter.Value), base.Apply()};
        }
    }
}