Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
03/09/11 11:17:48 (12 years ago)
Author:
svonolfe
Message:

Implemented wiring (#1425)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/VNS/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/VariableNeighborhoodSearch.cs

    r5622 r5642  
    3939      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
    4040    }
    41     public /*Constrained*/ValueParameter<ISingleObjectiveEvaluator> EvaluatorParameter {
    42       get { return (/*Constrained*/ValueParameter<ISingleObjectiveEvaluator>)Parameters["Evaluator"]; }
    43     }
    4441    private ValueParameter<ILocalImprovement> LocalImprovementParameter {
    4542      get { return (ValueParameter<ILocalImprovement>)Parameters["LocalImprovement"]; }
    4643    }
    47     private ValueParameter<ShakingOperator> ShakingParameter {
    48       get { return (ValueParameter<ShakingOperator>)Parameters["Shaking"]; }
     44    private ValueParameter<IShakingOperator> ShakingParameter {
     45      get { return (ValueParameter<IShakingOperator>)Parameters["Shaking"]; }
    4946    }
    5047    private ValueParameter<IntValue> MaximumIterationsParameter {
     
    5350    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
    5451      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
     52    }
     53    private VariableNeighborhoodSearchMainLoop VNSMainLoop {
     54      get { return FindMainLoop(SolutionsCreator.Successor); }
    5555    }
    5656    #endregion
     
    6060      get { return (RandomCreator)OperatorGraph.InitialOperator; }
    6161    }
    62     #endregion
     62    public MultiAnalyzer Analyzer {
     63      get { return AnalyzerParameter.Value; }
     64      set { AnalyzerParameter.Value = value; }
     65    }
     66    private SolutionsCreator SolutionsCreator {
     67      get { return (SolutionsCreator)RandomCreator.Successor; }
     68    }
     69    #endregion
     70
     71    [Storable]
     72    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
    6373
    6474    [StorableConstructor]
     
    7080    private VariableNeighborhoodSearch(VariableNeighborhoodSearch original, Cloner cloner)
    7181      : base(original, cloner) {
    72 
     82      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
     83      Initialize();
    7384    }
    7485    public override IDeepCloneable Clone(Cloner cloner) {
     
    7990      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
    8091      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
    81       Parameters.Add(new /*Constrained*/ValueParameter<ISingleObjectiveEvaluator>("Evaluator", "The operator used to evaluate the solutions."));
    8292      Parameters.Add(new ValueParameter<ILocalImprovement>("LocalImprovement", "The local improvement operation", new LocalSearchImprovement()));
    83       Parameters.Add(new ValueParameter<ShakingOperator>("Shaking", "The shaking operation", new ShakingOperator()));
     93      Parameters.Add(new ValueParameter<IShakingOperator>("Shaking", "The shaking operation"));
    8494      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(1000)));
    8595      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution and moves.", new MultiAnalyzer()));
     
    112122      mainLoop.LocalImprovementParameter.ActualName = LocalImprovementParameter.Name;
    113123      mainLoop.ShakingParameter.ActualName = ShakingParameter.Name;
    114       mainLoop.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
    115124      mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
    116125      mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
     
    119128      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
    120129
    121       /*Initialize();*/
    122     }
     130      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
     131      ParameterizeAnalyzers();
     132      UpdateAnalyzers();
     133
     134      Initialize();
     135    }
     136
     137    public override void Prepare() {
     138      if (Problem != null) base.Prepare();
     139    }
     140
     141    private void Initialize() {
     142      if (Problem != null) {
     143        Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
     144      }
     145    }
     146
     147    #region Events
     148    protected override void OnProblemChanged() {
     149      ParameterizeStochasticOperator(Problem.SolutionCreator);
     150      ParameterizeStochasticOperator(Problem.Evaluator);
     151      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
     152      ParameterizeSolutionsCreator();
     153      ParameterizeVNSMainLoop();
     154      ParameterizeAnalyzers();
     155      ParameterizeIterationBasedOperators();
     156      UpdateShakingOperator();
     157      UpdateLocalImprovementOperator();
     158      UpdateAnalyzers();
     159      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
     160      base.OnProblemChanged();
     161    }
     162
     163    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
     164      ParameterizeStochasticOperator(Problem.SolutionCreator);
     165      ParameterizeSolutionsCreator();
     166      base.Problem_SolutionCreatorChanged(sender, e);
     167    }
     168    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
     169      ParameterizeStochasticOperator(Problem.Evaluator);
     170      ParameterizeSolutionsCreator();
     171      ParameterizeVNSMainLoop();
     172      ParameterizeAnalyzers();
     173      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
     174      base.Problem_EvaluatorChanged(sender, e);
     175    }
     176    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
     177      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
     178      ParameterizeIterationBasedOperators();
     179      UpdateShakingOperator();
     180      UpdateLocalImprovementOperator();
     181      UpdateAnalyzers();
     182      base.Problem_OperatorsChanged(sender, e);
     183    }
     184
     185    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
     186      ParameterizeVNSMainLoop();
     187      ParameterizeAnalyzers();
     188    }
     189    #endregion
     190
     191    #region Helpers
     192    private void ParameterizeSolutionsCreator() {
     193      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
     194      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
     195    }
     196    private void ParameterizeStochasticOperator(IOperator op) {
     197      if (op is IStochasticOperator)
     198        ((IStochasticOperator)op).RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
     199    }
     200    private void ParameterizeVNSMainLoop() {
     201      VNSMainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
     202      VNSMainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
     203      VNSMainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
     204    }
     205    private void ParameterizeAnalyzers() {
     206      qualityAnalyzer.ResultsParameter.ActualName = "Results";
     207      if (Problem != null) {
     208        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
     209        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
     210        qualityAnalyzer.QualityParameter.Depth = 1;
     211        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
     212      }
     213    }
     214    private void ParameterizeIterationBasedOperators() {
     215      if (Problem != null) {
     216        foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
     217          op.IterationsParameter.ActualName = "OuterIterations";
     218          op.MaximumIterationsParameter.ActualName = "MaximumIterations";
     219        }
     220      }
     221    }
     222    private void UpdateShakingOperator() {
     223      Type manipulatorType = typeof(IManipulator);
     224      List<Type> manipulatorInterfaces = new List<Type>();
     225
     226      foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name)) {
     227        Type t = mutator.GetType();
     228        Type[] interfaces = t.GetInterfaces();
     229
     230        for(int i = 0; i < interfaces.Length; i++) {
     231          if (manipulatorType.IsAssignableFrom(interfaces[i])) {
     232            bool assignable = false;
     233            for (int j = 0; j < interfaces.Length; j++) {
     234              if (i != j && interfaces[i].IsAssignableFrom(interfaces[j])) {
     235                assignable = true;
     236                break;
     237              }
     238            }
     239
     240            if(!assignable)
     241              manipulatorInterfaces.Add(interfaces[i]);
     242          }         
     243        }
     244      }
     245
     246      foreach (Type manipulatorInterface in manipulatorInterfaces) {
     247        //manipulatorInterface is more specific
     248        if (manipulatorType.IsAssignableFrom(manipulatorInterface)) {
     249          //and compatible to all other found manipulator types
     250          bool compatible = true;
     251          foreach (Type manipulatorInterface2 in manipulatorInterfaces) {
     252            if (!manipulatorInterface.IsAssignableFrom(manipulatorInterface2)) {
     253              compatible = false;
     254              break;
     255            }
     256          }
     257
     258          if (compatible)
     259            manipulatorType = manipulatorInterface;
     260        }
     261      }
     262     
     263      Type genericType = typeof(ShakingOperator<>).MakeGenericType(manipulatorType);
     264      ShakingParameter.Value = (IShakingOperator)Activator.CreateInstance(genericType, new object[]{});
     265
     266      ShakingParameter.Value.Parameterize(Problem);
     267    }
     268    private void UpdateLocalImprovementOperator() {
     269      LocalImprovementParameter.Value.Parameterize(Problem);
     270    }
     271    private void UpdateAnalyzers() {
     272      Analyzer.Operators.Clear();
     273      if (Problem != null) {
     274        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
     275          foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
     276            param.Depth = 1;
     277          Analyzer.Operators.Add(analyzer);
     278        }
     279      }
     280      Analyzer.Operators.Add(qualityAnalyzer);
     281    }
     282    private VariableNeighborhoodSearchMainLoop FindMainLoop(IOperator start) {
     283      IOperator mainLoop = start;
     284      while (mainLoop != null && !(mainLoop is VariableNeighborhoodSearchMainLoop))
     285        mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
     286      if (mainLoop == null) return null;
     287      else return (VariableNeighborhoodSearchMainLoop)mainLoop;
     288    }
     289    #endregion
    123290  }
    124291}
Note: See TracChangeset for help on using the changeset viewer.