source: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinking.cs @ 7347

#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.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Random;

namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms {
  /// <summary>
  /// A genetic algorithm.
  /// </summary>
  [Item("GRASP+PR", "The algorithm combines the Greedy Randomized Adaptive Search Procedure (GRASP) with Path Relinking and is described in Mateus, G., Resende, M., and Silva, R. 2011. GRASP with path-relinking for the generalized quadratic assignment problem. Journal of Heuristics 17, Springer Netherlands, pp. 527-565.")]
  [Creatable("Algorithms")]
  [StorableClass]
  public sealed class GRASPWithPathRelinking : HeuristicOptimizationEngineAlgorithm {
    #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 IValueParameter<BoolValue> SetSeedRandomlyParameter {
      get { return (IValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
    }
    private IValueParameter<IntValue> SeedParameter {
      get { return (IValueParameter<IntValue>)Parameters["Seed"]; }
    }
    private IValueParameter<MultiAnalyzer> AnalyzerParameter {
      get { return (IValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    }
    private IValueParameter<IntValue> EliteSetSizeParameter {
      get { return (IValueParameter<IntValue>)Parameters["EliteSetSize"]; }
    }
    private IValueParameter<IntValue> LocalImprovementMaximumIterationsParameter {
      get { return (IValueParameter<IntValue>)Parameters["LocalImprovementMaximumIterations"]; }
    }
    private ConstrainedValueParameter<ILocalImprovementOperator> LocalImprovementParameter {
      get { return (ConstrainedValueParameter<ILocalImprovementOperator>)Parameters["LocalImprovement"]; }
    }
    public IFixedValueParameter<IntValue> MinimumEliteSetSizeParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters["MinimumEliteSetSize"]; }
    }
    public ConstrainedValueParameter<ICrossover> PathRelinkingParameter {
      get { return (ConstrainedValueParameter<ICrossover>)Parameters["PathRelinking"]; }
    }
    public ConstrainedValueParameter<IReplacer> EliteSetReplacerParameter {
      get { return (ConstrainedValueParameter<IReplacer>)Parameters["EliteSetReplacer"]; }
    }
    #endregion

    #region Properties
    public BoolValue SetSeedRandomly {
      get { return SetSeedRandomlyParameter.Value; }
      set { SetSeedRandomlyParameter.Value = value; }
    }
    public IntValue Seed {
      get { return SeedParameter.Value; }
      set { SeedParameter.Value = value; }
    }
    public MultiAnalyzer Analyzer {
      get { return AnalyzerParameter.Value; }
      set { AnalyzerParameter.Value = value; }
    }
    public IntValue EliteSetSize {
      get { return EliteSetSizeParameter.Value; }
      set { EliteSetSizeParameter.Value = value; }
    }
    public IntValue LocalImprovementMaximumIterations {
      get { return LocalImprovementMaximumIterationsParameter.Value; }
      set { LocalImprovementMaximumIterationsParameter.Value = value; }
    }

    private RandomCreator RandomCreator {
      get { return (RandomCreator)OperatorGraph.InitialOperator; }
    }
    #endregion

    [StorableConstructor]
    private GRASPWithPathRelinking(bool deserializing) : base(deserializing) { }
    private GRASPWithPathRelinking(GRASPWithPathRelinking original, Cloner cloner)
      : base(original, cloner) {
      // TODO: clone your private fields here
      RegisterEventHandlers();
    }
    public GRASPWithPathRelinking()
      : base() {
      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator."));
      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each iteration.", new MultiAnalyzer()));
      Parameters.Add(new ValueParameter<IntValue>("EliteSetSize", "The elite set stores the best found solutions.", new IntValue(10)));
      Parameters.Add(new ValueParameter<IntValue>("LocalImprovementMaximumIterations", "The maximum number of iterations performed by the local improvement operator.", new IntValue(100)));
      Parameters.Add(new ConstrainedValueParameter<ILocalImprovementOperator>("LocalImprovement", "Performs a local search on the solution.", null));
      Parameters.Add(new FixedValueParameter<IntValue>("MinimumEliteSetSize", "(ρ) The minimum amount of elites for performing path relinking.", new IntValue(1)));
      Parameters.Add(new ConstrainedValueParameter<ICrossover>("PathRelinking", "The operator that performs the path relinking."));
      Parameters.Add(new ConstrainedValueParameter<IReplacer>("EliteSetReplacer", "The operator that replaces solutions in the elite set."));

      RandomCreator randomCreator = new RandomCreator();
      OperatorGraph.InitialOperator = randomCreator;

      randomCreator.RandomParameter.ActualName = "Random";
      randomCreator.SeedParameter.ActualName = SeedParameter.Name;
      randomCreator.SeedParameter.Value = null;
      randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
      randomCreator.SetSeedRandomlyParameter.Value = null;

      var mainLoop = new GRASPWithPathRelinkingMainLoop();
      randomCreator.Successor = mainLoop;

      InitializeOperators();
      RegisterEventHandlers();
    }

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

    public override void Prepare() {
      if (Problem != null) base.Prepare();
    }

    #region Events
    protected override void OnProblemChanged() {
      // TODO: Initialize and parameterize operators
      InitializeOperators();
      base.OnProblemChanged();
    }

    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
      // TODO: Parameterize operators
      base.Problem_SolutionCreatorChanged(sender, e);
    }
    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
      // TODO: Parameterize operators
      base.Problem_EvaluatorChanged(sender, e);
    }
    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
      // TODO: Parameterize operators
      InitializeOperators();
      base.Problem_OperatorsChanged(sender, e);
    }
    #endregion

    #region Helpers
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (Problem != null) {
      }
    }

    private void RegisterEventHandlers() {

    }

    private void InitializeOperators() {
      Analyzer.Operators.Clear();
      if (Problem != null) {
        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
          foreach (var param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
            param.Depth = 1;
          Analyzer.Operators.Add(analyzer);
        }

        string oldLocalImprovement = String.Empty;
        if (LocalImprovementParameter.Value != null)
          oldLocalImprovement = LocalImprovementParameter.Value.Name;
        LocalImprovementParameter.ValidValues.Clear();
        foreach (ILocalImprovementOperator localImprovement in Problem.Operators.OfType<ILocalImprovementOperator>()) {
          LocalImprovementParameter.ValidValues.Add(localImprovement);
        }
        var newLocalImprovement = LocalImprovementParameter.ValidValues.FirstOrDefault(x => x.Name == oldLocalImprovement);
        if (newLocalImprovement != null) LocalImprovementParameter.Value = newLocalImprovement;

        string oldPathRelinking = String.Empty;
        if (PathRelinkingParameter.Value != null)
          oldPathRelinking = PathRelinkingParameter.Value.Name;
        PathRelinkingParameter.ValidValues.Clear();
        foreach (ICrossover pathRelinking in Problem.Operators.OfType<ICrossover>()) {
          PathRelinkingParameter.ValidValues.Add(pathRelinking);
        }
        var newPathRelinking = PathRelinkingParameter.ValidValues.FirstOrDefault(x => x.Name == oldPathRelinking);
        if (newPathRelinking != null) PathRelinkingParameter.Value = newPathRelinking;

        string oldReplacer = String.Empty;
        if (EliteSetReplacerParameter.Value != null)
          oldReplacer = EliteSetReplacerParameter.Value.Name;
        EliteSetReplacerParameter.ValidValues.Clear();
        foreach (IReplacer replacer in Problem.Operators.OfType<IReplacer>()) {
          EliteSetReplacerParameter.ValidValues.Add(replacer);
        }
        var newReplacer = EliteSetReplacerParameter.ValidValues.FirstOrDefault(x => x.Name == oldReplacer);
        if (newReplacer != null) EliteSetReplacerParameter.Value = newReplacer;
      }

      Parameterize();
    }

    private void Parameterize() {
      foreach (var localImprovement in LocalImprovementParameter.ValidValues) {
        localImprovement.MaximumIterationsParameter.ActualName = LocalImprovementMaximumIterationsParameter.Name;
        localImprovement.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
        localImprovement.ResultsParameter.ActualName = "Results";
        if (Problem != null && localImprovement.ProblemType.IsAssignableFrom(Problem.GetType()))
          localImprovement.Problem = Problem;
      }
    }
    #endregion
  }
}