Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinking.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinking.cs	(revision 7345)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinking.cs	(revision 7345)
@@ -0,0 +1,238 @@
+﻿#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
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinkingMainLoop.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinkingMainLoop.cs	(revision 7345)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinkingMainLoop.cs	(revision 7345)
@@ -0,0 +1,244 @@
+﻿#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.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms {
+  [Item("GRASP+PR MainLoop", "The main loop that implements the behavior of the GRASP+PR algorithm.")]
+  [StorableClass]
+  public class GRASPWithPathRelinkingMainLoop : AlgorithmOperator {
+    public IValueLookupParameter<IOperator> SolutionCreatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["SolutionCreator"]; }
+    }
+    public IValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
+    }
+    public IValueLookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+    public IValueLookupParameter<IntValue> EliteSetSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["EliteSetSize"]; }
+    }
+    public IValueLookupParameter<IOperator> LocalImprovementParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["LocalImprovement"]; }
+    }
+    public IValueLookupParameter<IOperator> PathRelinkingParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["PathRelinking"]; }
+    }
+    public IValueLookupParameter<IOperator> EliteSetReplacerParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["EliteSetReplacer"]; }
+    }
+    public IValueLookupParameter<IOperator> AnalyzerParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
+    }
+
+    [StorableConstructor]
+    protected GRASPWithPathRelinkingMainLoop(bool deserializing) : base(deserializing) { }
+    protected GRASPWithPathRelinkingMainLoop(GRASPWithPathRelinkingMainLoop original, Cloner cloner)
+      : base(original, cloner) { }
+    public GRASPWithPathRelinkingMainLoop()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IOperator>("SolutionCreator", "The solution creation procedure which ideally should be a greedy initialization heuristic."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The evaluator which calculates the fitness of a solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The number of maximum iterations that should be performed."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "Specifies where the results are stored."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("EliteSetSize", "The size of the elite set."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("LocalImprovement", "The operator which performs the local improvement."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("PathRelinking", "The operator which performs the path relinking."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("EliteSetReplacer", "The operator that replaces elements in the elite set."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The analyzer that is to be applied."));
+
+      var variableCreator1 = new VariableCreator();
+      variableCreator1.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
+
+      var variableCreator2 = new VariableCreator();
+      variableCreator2.CollectedValues.Add(new ValueParameter<IntValue>("ActualEliteSetSize", new IntValue(0));
+      variableCreator2.Name = "ActualEliteSetSize = 0";
+
+      var subScopesCounter1 = new SubScopesCounter();
+      subScopesCounter1.Name = "ActualEliteSetSize += |SubScopes|";
+      subScopesCounter1.ValueParameter.ActualName = "ActualEliteSetSize";
+
+      var comparator1 = new Comparator();
+      comparator1.Name = "ActualEliteSetSize >= MinimumEliteSetSize";
+      comparator1.Comparison.Value = ComparisonType.GreaterOrEqual;
+      comparator1.LeftSideParameter.ActualName = "ActualEliteSetSize";
+      comparator1.RightSideParameter.ActualName = EliteSetSizeParameter.ActualName;
+      comparator1.ResultParameter.ActualName = "SizeOkay";
+
+      var conditionalBranch1 = new ConditionalBranch();
+      conditionalBranch1.Name = "Elite set has at least ρ elements";
+      conditionalBranch1.ConditionParameter.ActualName = "SizeOkay";
+
+      var selector1 = new RandomSelector();
+      selector1.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
+      selector1.CopySelected.Value = true;
+
+      var selector2 = new RandomSelector();
+      selector2.NumberOfSelectedSubScopesParameter.Value = new IntValue(0);
+      
+      var ssp1 = new SubScopesProcessor();
+
+      var eo1 = new EmptyOperator();
+
+      var solutionsCreator = new SolutionsCreator();
+      solutionsCreator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
+      solutionsCreator.SolutionCreatorParameter.ActualName = SolutionCreatorParameter.Name;
+      solutionsCreator.NumberOfSolutions = new IntValue(1);
+      
+      var subScopesCounter2 = new SubScopesCounter();
+      subScopesCounter2.Name = "Count subscopes";
+      subScopesCounter2.ValueParameter.ActualName = "SolutionScopes";
+
+      var comparator2 = new Comparator();
+      comparator2.Name = "SolutionScopes == 2";
+      comparator2.Comparison.Value = ComparisonType.Equal;
+      comparator2.LeftSideParameter.ActualName = "SolutionScopes";
+      comparator2.RightSideParameter.Value = new IntValue(2);
+      comparator2.ResultParameter.ActualName = "PerformPR";
+
+      var conditionalBranch2 = new ConditionalBranch();
+      conditionalBranch2.Name = "Path relinking?";
+      conditionalBranch2.ConditionParameter.ActualName = "PerformPR";
+
+      var ssp2 = new SubScopesProcessor();
+
+      var eo2 = new EmptyOperator();
+
+      var placeholder1 = new Placeholder();
+      placeholder1.Name = "(LocalImprovement)";
+      placeholder1.OperatorParameter.ActualName = LocalImprovementParameter.Name;
+
+      var childrenCreator = new ChildrenCreator();
+      childrenCreator.ParentsPerChild = new IntValue(2);
+      
+      var placeholder2 = new Placeholder();
+      placeholder2.Name = "(PathRelinking)";
+      placeholder2.OperatorParameter.ActualName = PathRelinkingParameter.Name;
+
+      var subScopesRemover = new SubScopesRemover();
+      subScopesRemover.RemoveAllSubScopes = true;
+
+      var ssp3 = new SubScopesProcessor();
+
+      var placeholder3 = new Placeholder();
+      placeholder3.Name = "(LocalImprovement)";
+      placeholder3.OperatorParameter.ActualName = LocalImprovementParameter.Name;
+
+      var placeholder4 = new Placeholder();
+      placeholder4.Name = "(Replacer)";
+      placeholder4.OperatorParameter.ActualName = EliteSetReplacerParameter.Name;
+
+      var counter = new IntCounter();
+      counter.Name = "Iterations++";
+      counter.ValueParameter.ActualName = "Iterations";
+      counter.Increment = new IntValue(1);
+
+      var analyzer1 = new Placeholder();
+      analyzer1.Name = "(Analyzer)";
+      analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
+
+      var comparator3 = new Comparator();
+      comparator3.Name = "Iterations >= MaximumIterations";
+      comparator3.Comparison.Value = ComparisonType.GreaterOrEqual;
+      comparator3.LeftSideParameter.ActualName = "Iterations";
+      comparator3.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
+      comparator3.ResultParameter.ActualName = "TerminatedByIteration";
+
+      var conditionalBranch3 = new ConditionalBranch();
+      conditionalBranch3.Name = "Terminate by Iterations?";
+      conditionalBranch3.ConditionParameter.ActualName = "TerminatedByIteration";
+
+      OperatorGraph.InitialOperator = variableCreator1;
+      variableCreator1.Successor = variableCreator2;
+      variableCreator2.Successor = subScopesCounter1;
+      subScopesCounter1.Successor = comparator1;
+      comparator1.Successor = conditionalBranch1;
+      conditionalBranch1.TrueBranch = selector1;
+      conditionalBranch1.FalseBranch = selector2;
+      conditionalBranch1.Successor = ssp1;
+      ssp1.Operators.Add(eo1);
+      ssp1.Operators.Add(solutionsCreator);
+      ssp1.Successor = placeholder4;
+      eo1.Successor = null;
+      solutionsCreator.Successor = subScopesCounter2;
+      subScopesCounter2.Successor = comparator2;
+      comparator2.Successor = conditionalBranch2;
+      conditionalBranch2.TrueBranch = ssp2;
+      conditionalBranch2.FalseBranch = null;
+      conditionalBranch2.Successor = ssp3;
+      ssp2.Operators.Add(eo2);
+      ssp2.Operators.Add(placeholder1);
+      ssp2.Successor = null;
+      eo2.Successor = null;
+      placeholder1.Successor = childrenCreator;
+      childrenCreator.Successor = placeholder2;
+      placeholder2.Successor = subScopesRemover;
+      subScopesRemover.Successor = null;
+      ssp3.Operators.Add(placeholder3);
+      ssp3.Successor = null;
+      placeholder4.Successor = counter;
+      counter.Successor = analyzer1;
+      analyzer1.Successor = comparator3;
+      comparator3.Successor = conditionalBranch3;
+      conditionalBranch3.TrueBranch = null;
+      conditionalBranch3.FalseBranch = variableCreator2;
+      conditionalBranch3.Successor = null;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GRASPWithPathRelinkingMainLoop(this, cloner);
+    }
+
+    private void Parameterize() {
+      var operators = OperatorGraph.InitialOperator.Walk().ToArray();
+
+      foreach (var solutionsCreator in operators.OfType<SolutionsCreator>()) {
+        solutionsCreator.SolutionCreatorParameter.ActualName = SolutionCreatorParameter.Name;
+        solutionsCreator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
+      }
+    }
+
+    public event EventHandler ProblemChanged;
+    protected virtual void OnProblemChanged() {
+      Parameterize();
+      var handler = ProblemChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms.3.3.csproj
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms.3.3.csproj	(revision 7345)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms.3.3.csproj	(revision 7345)
@@ -0,0 +1,76 @@
+﻿<?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>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{53AB48BF-532F-417D-B98B-745105BB447A}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>C:\Program Files\HeuristicLab 3.3\PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Data" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <None Include="Properties\AssemblyInfo.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd</PreBuildEvent>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
+  <!-- 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>
+  -->
+</Project>
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/Plugin.cs.frame
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/Plugin.cs.frame	(revision 7345)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/Plugin.cs.frame	(revision 7345)
@@ -0,0 +1,29 @@
+﻿#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.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms {
+  [Plugin("HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms", "3.3.6.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms-3.3.dll", PluginFileType.Assembly)]
+  public class HeuristicLabProblemsGeneralizedQuadraticAssignmentAlgorithmsPlugin : PluginBase {
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/Properties/AssemblyInfo.frame
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/Properties/AssemblyInfo.frame	(revision 7345)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/Properties/AssemblyInfo.frame	(revision 7345)
@@ -0,0 +1,57 @@
+﻿#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.Reflection;
+using System.Runtime.CompilerServices;
+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.Problems.GeneralizedQuadraticAssignment.Algorithms")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2012 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("7c14407e-6980-465b-ba3a-4a916d48989b")]
+
+// 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("1.0.*")]
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.6.$WCREV$")]
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/Plugin.cs.frame
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/Plugin.cs.frame	(revision 7319)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/Plugin.cs.frame	(revision 7345)
@@ -23,5 +23,5 @@
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views {
-  [Plugin("HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views", "3.3.5.$WCREV$")]
+  [Plugin("HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views", "3.3.6.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/Properties/AssemblyInfo.cs.frame	(revision 7319)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/Properties/AssemblyInfo.cs.frame	(revision 7345)
@@ -54,3 +54,3 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.5.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.6.$WCREV$")]
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/ExtensionMethods.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/ExtensionMethods.cs	(revision 7319)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/ExtensionMethods.cs	(revision 7345)
@@ -74,4 +74,31 @@
     }
 
+    /// <summary>
+    /// Walks an operator graph in that it jumps from one operator to all its operator parameters and yields each operator it touches.
+    /// Cycles are detected and not walked twice.
+    /// </summary>
+    /// <param name="initial">The operator where the walk starts (is also yielded).</param>
+    /// <returns>An enumeration of all the operators that could be found.</returns>
+    public static IEnumerable<IOperator> Walk(this IOperator initial) {
+      var open = new Stack<IOperator>();
+      var visited = new HashSet<IOperator>();
+      open.Push(initial);
+
+      while (open.Any()) {
+        IOperator current = open.Pop();
+        if (visited.Contains(current)) continue;
+        visited.Add(current);
+
+        foreach (var parameter in current.Parameters.OfType<IValueParameter>()) {
+          if (typeof(IOperator).IsAssignableFrom(parameter.DataType)) {
+            if (parameter.Value != null)
+              open.Push((IOperator)parameter.Value);
+          }
+        }
+
+        yield return current;
+      }
+    }
+
   }
 }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Plugin.cs.frame
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Plugin.cs.frame	(revision 7319)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Plugin.cs.frame	(revision 7345)
@@ -23,5 +23,5 @@
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  [Plugin("HeuristicLab.Problems.GeneralizedQuadraticAssignment", "3.3.5.$WCREV$")]
+  [Plugin("HeuristicLab.Problems.GeneralizedQuadraticAssignment", "3.3.6.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.GeneralizedQuadraticAssignment-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Properties/AssemblyInfo.cs.frame	(revision 7319)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Properties/AssemblyInfo.cs.frame	(revision 7345)
@@ -55,3 +55,3 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.5.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.6.$WCREV$")]
