source: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs @ 10850

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.BinaryVectorEncoding;
using HeuristicLab.Encodings.IntegerVectorEncoding;
using HeuristicLab.Encodings.PermutationEncoding;
using HeuristicLab.Encodings.RealVectorEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;

namespace HeuristicLab.Problems.Programmable {
  [Item("Programmable Problem (single-objective)", "Represents a single-objective problem that can be programmed.")]
  [Creatable("Problems")]
  [StorableClass]
  public class SingleObjectiveProgrammableProblem : SingleObjectiveHeuristicOptimizationProblem<ISingleObjectiveProgrammableProblemEvaluator, ISolutionCreator>, IParameterizedNamedItem, IStorableContent {
    public string Filename { get; set; }

    public static new Image StaticItemImage {
      get { return HeuristicLab.Common.Resources.VSImageLibrary.Script; }
    }

    public new ParameterCollection Parameters {
      get { return base.Parameters; }
    }
    IKeyedItemCollection<string, IParameter> IParameterizedItem.Parameters {
      get { return Parameters; }
    }

    public IValueParameter<SingleObjectiveScript> ScriptParameter {
      get { return (IValueParameter<SingleObjectiveScript>)Parameters["Script"]; }
    }

    public IValueParameter<Configuration> ConfigurationParameter {
      get { return (IValueParameter<Configuration>)Parameters["Configuration"]; }
    }

    [Storable]
    protected List<IParameter> DynamicConfigurationParameters;

    [StorableConstructor]
    protected SingleObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }

    protected SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem original, Cloner cloner)
      : base(original, cloner) {
      DynamicConfigurationParameters = original.DynamicConfigurationParameters.Select(cloner.Clone).ToList();
      RegisterEventHandlers();
    }
    public SingleObjectiveProgrammableProblem()
      : base(new SingleObjectiveEvaluator(), new ParameterVectorCreater()) {
      Parameters.Add(new ValueParameter<SingleObjectiveScript>("Script", "Defines the problem.", new SingleObjectiveScript() { Name = ItemName }));
      Parameters.Add(new ValueParameter<Configuration>("Configuration", "Describes which parameters exist, what they're called, what type they are and their bounds if any."));

      DynamicConfigurationParameters = new List<IParameter>();

      Operators.Add(new BestScopeSolutionAnalyzer());
      Operators.Add(Evaluator);
      Operators.Add(SolutionCreator);

      RegisterEventHandlers();
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new SingleObjectiveProgrammableProblem(this, cloner);
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegisterEventHandlers();
    }

    private void RegisterEventHandlers() {
      ScriptParameter.ValueChanged += ScriptParameterOnValueChanged;
      RegisterScriptInstanceChanges();
    }

    private void ScriptParameterOnValueChanged(object sender, EventArgs eventArgs) {
      RegisterScriptInstanceChanges();
    }

    private void RegisterScriptInstanceChanges() {
      ScriptParameter.Value.InstanceChanged += ScriptOnInstanceChanged;
      ScriptParameter.Value.NameChanged += ScriptOnNameChanged;
    }

    private void ScriptOnNameChanged(object sender, EventArgs eventArgs) {
      if (sender != ScriptParameter.Value) return;
      if (Name != ScriptParameter.Value.Name)
        Name = ScriptParameter.Value.Name;
    }

    protected override void OnNameChanged() {
      base.OnNameChanged();
      if (ScriptParameter.Value.Name != Name)
        ScriptParameter.Value.Name = Name;
    }

    protected virtual void ScriptOnInstanceChanged(object sender, EventArgs eventArgs) {

      var instance = ScriptParameter.Value.Instance;
      if (instance == null) return;

      var configuration = instance.GetConfiguration();
      ConfigurationParameter.Value = configuration;
      Maximization.Value = configuration.Maximization;

      foreach (var param in DynamicConfigurationParameters)
        if (Parameters.Contains(param)) Parameters.Remove(param);
      DynamicConfigurationParameters.Clear();

      var solutionCreators = new List<ISolutionCreator>();
      foreach (var parameters in configuration.Parameters) {
        var binConfig = parameters.Value as BinaryParameterConfiguration;
        if (binConfig != null) {
          var p = new ValueParameter<IntValue>(parameters.Key + "Length", binConfig.Length);
          DynamicConfigurationParameters.Add(p);

          var creator = new RandomBinaryVectorCreator();
          creator.BinaryVectorParameter.ActualName = parameters.Key;
          creator.LengthParameter.ActualName = p.Name;
          solutionCreators.Add(creator);
        }
        var intConfig = parameters.Value as IntegerParameterConfiguration;
        if (intConfig != null) {
          var l = new ValueParameter<IntValue>(parameters.Key + "Length", intConfig.Length);
          var b = new ValueParameter<IntMatrix>(parameters.Key + "Bounds", intConfig.Bounds);
          DynamicConfigurationParameters.Add(l);
          DynamicConfigurationParameters.Add(b);

          var creator = new UniformRandomIntegerVectorCreator();
          creator.IntegerVectorParameter.ActualName = parameters.Key;
          creator.LengthParameter.ActualName = l.Name;
          creator.BoundsParameter.ActualName = b.Name;
          solutionCreators.Add(creator);
        }
        var realConfig = parameters.Value as RealParameterConfiguration;
        if (realConfig != null) {
          var l = new ValueParameter<IntValue>(parameters.Key + "Length", realConfig.Length);
          var b = new ValueParameter<DoubleMatrix>(parameters.Key + "Bounds", realConfig.Bounds);
          DynamicConfigurationParameters.Add(l);
          DynamicConfigurationParameters.Add(b);

          var creator = new UniformRandomRealVectorCreator();
          creator.RealVectorParameter.ActualName = parameters.Key;
          creator.LengthParameter.ActualName = l.Name;
          creator.BoundsParameter.ActualName = b.Name;
          solutionCreators.Add(creator);
        }
        var permConfig = parameters.Value as PermutationParameterConfiguration;
        if (permConfig != null) {
          var l = new ValueParameter<IntValue>(parameters.Key + "Length", permConfig.Length);
          DynamicConfigurationParameters.Add(l);

          var creator = new RandomPermutationCreator();
          creator.PermutationParameter.ActualName = parameters.Key;
          creator.LengthParameter.ActualName = l.Name;
          creator.PermutationTypeParameter.Value = permConfig.Type;
          solutionCreators.Add(creator);
        }
      }

      foreach (var param in DynamicConfigurationParameters) {
        param.Hidden = true;
        Parameters.Add(param);
      }

      // use specialized creators if the configuration consists only of a single parameter type
      // this allows to use specialized algorithms such as CMA-ES
      if (solutionCreators.Count == 1) { // single-vector encoding
        Operators.RemoveAll(x => x is ICrossover);
        Operators.RemoveAll(x => x is IManipulator);
        var newCreator = solutionCreators.Single();
        var binCreator = newCreator as IBinaryVectorCreator;
        if (binCreator != null) {
          // do not replace a binary vector creator that was manually set
          if (!(SolutionCreator is IBinaryVectorCreator)
              || ((IBinaryVectorCreator)SolutionCreator).BinaryVectorParameter.ActualName != binCreator.BinaryVectorParameter.ActualName) {
            Operators.Remove(SolutionCreator);
            SolutionCreator = newCreator;
            Operators.Add(SolutionCreator);
          }
          var crossovers = ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>().ToList();
          var manipulators = ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>().ToList();
          foreach (var xo in crossovers) {
            xo.ChildParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
            xo.ParentsParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
          }
          foreach (var m in manipulators)
            m.BinaryVectorParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
          Operators.AddRange(crossovers);
          Operators.AddRange(manipulators);
        }
        var intCreator = newCreator as IIntegerVectorCreator;
        if (intCreator != null) {
          // do not replace an integer vector creator that was manually set
          if (!(SolutionCreator is IIntegerVectorCreator)
              || ((IIntegerVectorCreator)SolutionCreator).IntegerVectorParameter.ActualName != intCreator.IntegerVectorParameter.ActualName) {
            Operators.Remove(SolutionCreator);
            SolutionCreator = newCreator;
            Operators.Add(SolutionCreator);
          }
          var crossovers = ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>().ToList();
          var manipulators = ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>().ToList();
          foreach (var xo in crossovers) {
            xo.ChildParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
            xo.ParentsParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
          }
          foreach (var m in manipulators)
            m.IntegerVectorParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
          foreach (var bo in crossovers.OfType<IBoundedIntegerVectorOperator>().Concat(manipulators.OfType<IBoundedIntegerVectorOperator>()).ToList()) {
            bo.BoundsParameter.ActualName = intCreator.BoundsParameter.ActualName;
          }
          Operators.AddRange(crossovers);
          Operators.AddRange(manipulators);
        }
        var realCreator = newCreator as IRealVectorCreator;
        if (realCreator != null) {
          // do not replace a real vector creator that was manually set
          if (!(SolutionCreator is IRealVectorCreator)
              || ((IRealVectorCreator)SolutionCreator).RealVectorParameter.ActualName != realCreator.RealVectorParameter.ActualName) {
            Operators.Remove(SolutionCreator);
            SolutionCreator = newCreator;
            Operators.Add(SolutionCreator);
          }
          var crossovers = ApplicationManager.Manager.GetInstances<IRealVectorCrossover>().ToList();
          var manipulators = ApplicationManager.Manager.GetInstances<IRealVectorManipulator>().ToList();
          foreach (var xo in crossovers) {
            xo.ChildParameter.ActualName = realCreator.RealVectorParameter.ActualName;
            xo.ParentsParameter.ActualName = realCreator.RealVectorParameter.ActualName;
            xo.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
          }
          foreach (var m in manipulators) {
            m.RealVectorParameter.ActualName = realCreator.RealVectorParameter.ActualName;
            m.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
          }
          Operators.AddRange(crossovers);
          Operators.AddRange(manipulators);
        }
        var permCreator = newCreator as IPermutationCreator;
        if (permCreator != null) {
          // do not replace a permutation creator that was manually set
          if (!(SolutionCreator is IPermutationCreator)
              || ((IPermutationCreator)SolutionCreator).PermutationParameter.ActualName != permCreator.PermutationParameter.ActualName) {
            Operators.Remove(SolutionCreator);
            SolutionCreator = newCreator;
            Operators.Add(SolutionCreator);
          }
          var crossovers = ApplicationManager.Manager.GetInstances<IPermutationCrossover>().ToList();
          var manipulators = ApplicationManager.Manager.GetInstances<IPermutationManipulator>().ToList();
          foreach (var xo in crossovers) {
            xo.ChildParameter.ActualName = permCreator.PermutationParameter.ActualName;
            xo.ParentsParameter.ActualName = permCreator.PermutationParameter.ActualName;
          }
          foreach (var m in manipulators)
            m.PermutationParameter.ActualName = permCreator.PermutationParameter.ActualName;
          Operators.AddRange(crossovers);
          Operators.AddRange(manipulators);
        }
      } else { // multi-vector encoding
        var oldCreator = SolutionCreator as ParameterVectorCreater;
        var newCreator = new ParameterVectorCreater();
        var newBinParams = new HashSet<string>(solutionCreators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
        if (oldCreator != null) { // we want to reuse the old creator
          var oldParams = new HashSet<string>(oldCreator
            .BeforeExecutionOperators.OfType<IBinaryVectorCreator>()
            .Select(x => x.BinaryVectorParameter.ActualName));
          foreach (var toAdd in newBinParams.Except(oldParams)) {
            var paramName = toAdd;
            oldCreator.BeforeExecutionOperators.Add(solutionCreators.OfType<IBinaryVectorCreator>().Single(x => x.BinaryVectorParameter.ActualName == paramName));
          }
          foreach (var toRemove in oldParams.Except(newBinParams)) {
            var paramName = toRemove;
            oldCreator.BeforeExecutionOperators.RemoveAll(
              op => op is IBinaryVectorCreator && ((IBinaryVectorCreator)op).BinaryVectorParameter.ActualName == paramName);
          }
        } else { // we will use the new creator
          foreach (var binCreator in solutionCreators.OfType<IBinaryVectorCreator>()) {
            newCreator.BeforeExecutionOperators.Add(binCreator);
          }
        }

        var newIntParams = new HashSet<string>(solutionCreators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
        if (oldCreator != null) { // we want to reuse the old creator
          var oldParams = new HashSet<string>(oldCreator
            .BeforeExecutionOperators.OfType<IIntegerVectorCreator>()
            .Select(x => x.IntegerVectorParameter.ActualName));
          foreach (var toAdd in newIntParams.Except(oldParams)) {
            var paramName = toAdd;
            oldCreator.BeforeExecutionOperators.Add(solutionCreators.OfType<IIntegerVectorCreator>().Single(x => x.IntegerVectorParameter.ActualName == paramName));
          }
          foreach (var toRemove in oldParams.Except(newIntParams)) {
            var paramName = toRemove;
            oldCreator.BeforeExecutionOperators.RemoveAll(
              op => op is IIntegerVectorCreator && ((IIntegerVectorCreator)op).IntegerVectorParameter.ActualName == paramName);
          }
        } else { // we will use the new creator
          foreach (var intCreator in solutionCreators.OfType<IIntegerVectorCreator>()) {
            newCreator.BeforeExecutionOperators.Add(intCreator);
          }
        }

        var newRealParams = new HashSet<string>(solutionCreators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
        if (oldCreator != null) { // we want to reuse the old creator
          var oldParams = new HashSet<string>(oldCreator
            .BeforeExecutionOperators.OfType<IRealVectorCreator>()
            .Select(x => x.RealVectorParameter.ActualName));
          foreach (var toAdd in newRealParams.Except(oldParams)) {
            var paramName = toAdd;
            oldCreator.BeforeExecutionOperators.Add(solutionCreators.OfType<IRealVectorCreator>().Single(x => x.RealVectorParameter.ActualName == paramName));
          }
          foreach (var toRemove in oldParams.Except(newRealParams)) {
            var paramName = toRemove;
            oldCreator.BeforeExecutionOperators.RemoveAll(
              op => op is IRealVectorCreator && ((IRealVectorCreator)op).RealVectorParameter.ActualName == paramName);
          }
        } else { // we will use the new creator
          foreach (var realCreator in solutionCreators.OfType<IRealVectorCreator>()) {
            newCreator.BeforeExecutionOperators.Add(realCreator);
          }
        }

        var newPermParams = new HashSet<string>(solutionCreators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
        if (oldCreator != null) { // we want to reuse the old creator
          var oldParams = new HashSet<string>(oldCreator
            .BeforeExecutionOperators.OfType<IPermutationCreator>()
            .Select(x => x.PermutationParameter.ActualName));
          foreach (var toAdd in newPermParams.Except(oldParams)) {
            var paramName = toAdd;
            oldCreator.BeforeExecutionOperators.Add(solutionCreators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == paramName));
          }
          foreach (var toRemove in oldParams.Except(newPermParams)) {
            var paramName = toRemove;
            oldCreator.BeforeExecutionOperators.RemoveAll(
              op => op is IPermutationCreator && ((IPermutationCreator)op).PermutationParameter.ActualName == paramName);
          }
          // we also have to sync the permutation type (in case this changes, as it is a value parameter)
          foreach (var intersect in newPermParams.Intersect(oldParams)) {
            var paramName = intersect;
            var oldPermCreator = oldCreator.BeforeExecutionOperators.OfType<IPermutationCreator>()
              .Single(x => x.PermutationParameter.ActualName == paramName);
            var newPermCreator = solutionCreators.OfType<IPermutationCreator>()
                .Single(x => x.PermutationParameter.ActualName == paramName);
            oldPermCreator.PermutationTypeParameter.Value = newPermCreator.PermutationTypeParameter.Value;
          }
        } else { // we will use the new creator
          foreach (var permCreator in solutionCreators.OfType<IPermutationCreator>()) {
            newCreator.BeforeExecutionOperators.Add(permCreator);
          }
        }
      }
    }
  }
}