Changeset 17695 for branches/2521_ProblemRefactoring/HeuristicLab.Optimization

Timestamp:

07/23/20 16:21:55 (4 years ago)

Author:

abeham

Message:

#2521:

• Moving solution creator parameter from problems to algorithms (breaking wiring in some HeuristicOptimizationProblems)
• Disallowing evaluator or encoding changes in encoding-specific base problems (to avoid confusion in derived problems whether this needs to be handled or not)
• Added private set to ReferenceParameter property (serialization)

Location:

branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3

Files:

• Algorithms/HeuristicOptimizationAlgorithm.cs (deleted)
• Algorithms/HeuristicOptimizationEngineAlgorithm.cs (modified) (2 diffs)
• BasicProblems/Problem.cs (modified) (6 diffs)
• HeuristicLab.Optimization-3.3.csproj (modified) (1 diff)
• Interfaces/IHeuristicOptimizationProblem.cs (modified) (1 diff)
• Problems/HeuristicOptimizationProblem.cs (modified) (5 diffs)
• Problems/MultiObjectiveHeuristicOptimizationProblem.cs (modified) (2 diffs)
• Problems/SingleObjectiveHeuristicOptimizationProblem.cs (modified) (3 diffs)
• Problems/UserDefinedProblem.cs (modified) (6 diffs)

branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Algorithms/HeuristicOptimizationEngineAlgorithm.cs

@@ -21 +21 @@
 
 using System;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HEAL.Attic;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Optimization {
@@ -37 +38 @@
     }
 
-    protected HeuristicOptimizationEngineAlgorithm() : base() { }
-    protected HeuristicOptimizationEngineAlgorithm(string name) : base(name) { }
-    protected HeuristicOptimizationEngineAlgorithm(string name, ParameterCollection parameters) : base(name, parameters) { }
-    protected HeuristicOptimizationEngineAlgorithm(string name, string description) : base(name, description) { }
-    protected HeuristicOptimizationEngineAlgorithm(string name, string description, ParameterCollection parameters) : base(name, description, parameters) { }
+    [Storable] public IConstrainedValueParameter<ISolutionCreator> SolutionCreatorParameter { get; private set; }
+    public ISolutionCreator SolutionCreator {
+      get => SolutionCreatorParameter.Value;
+      set {
+        if (!SolutionCreatorParameter.ValidValues.Contains(value))
+          SolutionCreatorParameter.ValidValues.Add(value);
+        SolutionCreatorParameter.Value = value;
+      }
+    }
+
+    protected HeuristicOptimizationEngineAlgorithm() : base() {
+      Parameters.Add(SolutionCreatorParameter = new ConstrainedValueParameter<ISolutionCreator>("SolutionCreator", "An operator that creates a solution for a given problem."));
+
+      RegisterEventHandlers();
+    }
+    protected HeuristicOptimizationEngineAlgorithm(string name) : base(name) {
+      Parameters.Add(SolutionCreatorParameter = new ConstrainedValueParameter<ISolutionCreator>("SolutionCreator", "An operator that creates a solution for a given problem."));
+
+      RegisterEventHandlers();
+    }
+    protected HeuristicOptimizationEngineAlgorithm(string name, ParameterCollection parameters) : base(name, parameters) {
+      Parameters.Add(SolutionCreatorParameter = new ConstrainedValueParameter<ISolutionCreator>("SolutionCreator", "An operator that creates a solution for a given problem."));
+
+      RegisterEventHandlers();
+    }
+    protected HeuristicOptimizationEngineAlgorithm(string name, string description) : base(name, description) {
+      Parameters.Add(SolutionCreatorParameter = new ConstrainedValueParameter<ISolutionCreator>("SolutionCreator", "An operator that creates a solution for a given problem."));
+
+      RegisterEventHandlers();
+    }
+    protected HeuristicOptimizationEngineAlgorithm(string name, string description, ParameterCollection parameters) : base(name, description, parameters) {
+      Parameters.Add(SolutionCreatorParameter = new ConstrainedValueParameter<ISolutionCreator>("SolutionCreator", "An operator that creates a solution for a given problem."));
+
+      RegisterEventHandlers();
+    }
 
     [StorableConstructor]
     protected HeuristicOptimizationEngineAlgorithm(StorableConstructorFlag _) : base(_) { }
-    protected HeuristicOptimizationEngineAlgorithm(HeuristicOptimizationEngineAlgorithm original, Cloner cloner) : base(original, cloner) { }
+    protected HeuristicOptimizationEngineAlgorithm(HeuristicOptimizationEngineAlgorithm original, Cloner cloner) : base(original, cloner) {
+      SolutionCreatorParameter = cloner.Clone(original.SolutionCreatorParameter);
+
+      RegisterEventHandlers();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
 
     #region Events
+    private void RegisterEventHandlers() {
+      ParameterChangeHandler<ISolutionCreator>.Create(SolutionCreatorParameter, SolutionCreatorOnChanged);
+    }
     protected override void DeregisterProblemEvents() {
-      Problem.SolutionCreatorChanged -= new EventHandler(Problem_SolutionCreatorChanged);
-      Problem.EvaluatorChanged -= new EventHandler(Problem_EvaluatorChanged);
+      Problem.EvaluatorChanged -= Problem_EvaluatorChanged;
       base.DeregisterProblemEvents();
     }
     protected override void RegisterProblemEvents() {
       base.RegisterProblemEvents();
-      Problem.SolutionCreatorChanged += new EventHandler(Problem_SolutionCreatorChanged);
-      Problem.EvaluatorChanged += new EventHandler(Problem_EvaluatorChanged);
+      Problem.EvaluatorChanged += Problem_EvaluatorChanged;
+    }
+    protected override void OnProblemChanged() {
+      base.OnProblemChanged();
+      SolutionCreatorParameter.Repopulate(Problem.Operators);
     }
 
-    protected virtual void Problem_SolutionCreatorChanged(object sender, EventArgs e) { }
+    protected virtual void SolutionCreatorOnChanged() { }
     protected virtual void Problem_EvaluatorChanged(object sender, EventArgs e) { }
+
+    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
+      base.Problem_OperatorsChanged(sender, e);
+      SolutionCreatorParameter.Repopulate(Problem.Operators);
+    }
     #endregion
   }

branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs

@@ -37 +37 @@
     where TEvaluator : class, IEvaluator {
 
-    [Storable] protected ConstrainedValueParameter<ISolutionCreator> SolutionCreatorParameter { get; private set; }
-
     //TODO remove parameter for encoding?
     protected IValueParameter<TEncoding> EncodingParameter {
@@ -50 +48 @@
         if (value == null) throw new ArgumentNullException("Encoding must not be null.");
         EncodingParameter.Value = value;
-      }
-    }
-
-    ISolutionCreator IHeuristicOptimizationProblem.SolutionCreator { get => SolutionCreatorParameter.Value; }
-    IParameter IHeuristicOptimizationProblem.SolutionCreatorParameter { get => SolutionCreatorParameter; }
-
-    event EventHandler IHeuristicOptimizationProblem.SolutionCreatorChanged {
-      add {
-        SolutionCreatorParameter.ValueChanged += value;
-      }
-      remove {
-        SolutionCreatorParameter.ValueChanged -= value;
       }
     }
@@ -103 +89 @@
       Parameters.Add(new ValueParameter<TEncoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any.", encoding) { Hidden = true });
       Parameters.Add(new ValueParameter<TEvaluator>("Evaluator", "The operator used to evaluate a solution.") { Hidden = true });
-      Parameters.Add(SolutionCreatorParameter = new ConstrainedValueParameter<ISolutionCreator>("SolutionCreator", "The operator used to create a solution."));
-
+      
       oldEncoding = Encoding;
       Parameterize();
@@ -114 +99 @@
       : base(original, cloner) {
       oldEncoding = cloner.Clone(original.oldEncoding);
-      SolutionCreatorParameter = cloner.Clone(original.SolutionCreatorParameter);
       RegisterEvents();
     }
@@ -123 +107 @@
     private void AfterDeserialization() {
       oldEncoding = Encoding;
-      // TODO: remove below
-      if (SolutionCreatorParameter == null) Parameters.Add(SolutionCreatorParameter = new ConstrainedValueParameter<ISolutionCreator>("SolutionCreator", "The operator used to create a solution."));
-
       RegisterEvents();
     }
@@ -160 +141 @@
       Encoding.ConfigureOperators(Operators);
 
-      SolutionCreatorParameter.Repopulate(GetOperators());
       //var multiEncoding = Encoding as MultiEncoding;
       //if (multiEncoding != null) multiEncoding.EncodingsChanged += MultiEncodingOnEncodingsChanged;

branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj

@@ -203 +203 @@
     <Compile Include="Algorithms\HeuristicOptimizationEngineAlgorithm.cs" />
     <Compile Include="Interfaces\ILocalImprovementOperator.cs" />
-    <Compile Include="Algorithms\HeuristicOptimizationAlgorithm.cs" />
     <Compile Include="Interfaces\IMultiNeighborhoodShakingOperator.cs" />
     <Compile Include="MoveHelper.cs" />

branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IHeuristicOptimizationProblem.cs

@@ -30 +30 @@
   /// </summary>
   public interface IHeuristicOptimizationProblem : IEncodedProblem {
-    IParameter SolutionCreatorParameter { get; }
-    ISolutionCreator SolutionCreator { get; }
     IParameter EvaluatorParameter { get; }
     IEvaluator Evaluator { get; }
 
-    event EventHandler SolutionCreatorChanged;
     event EventHandler EvaluatorChanged;
   }

branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Problems/HeuristicOptimizationProblem.cs

@@ -29 +29 @@
   [Item("Heuristic Optimization Problem", "Represents the base class for a heuristic optimization problem.")]
   [StorableType("DE0478BA-3797-4AC3-9A89-3734D2643823")]
-  public abstract class HeuristicOptimizationProblem<T, U> : EncodedProblem, IHeuristicOptimizationProblem
-    where T : class, IEvaluator
-    where U : class, ISolutionCreator {
+  public abstract class HeuristicOptimizationProblem<T> : EncodedProblem, IHeuristicOptimizationProblem
+    where T : class, IEvaluator {
     private const string EvaluatorParameterName = "Evaluator";
-    private const string SolutionCreateParameterName = "SolutionCreator";
 
     [StorableConstructor]
     protected HeuristicOptimizationProblem(StorableConstructorFlag _) : base(_) { }
-    protected HeuristicOptimizationProblem(HeuristicOptimizationProblem<T, U> original, Cloner cloner)
+    protected HeuristicOptimizationProblem(HeuristicOptimizationProblem<T> original, Cloner cloner)
       : base(original, cloner) {
       RegisterEventHandlers();
@@ -45 +43 @@
       : base() {
       Parameters.Add(new ValueParameter<T>(EvaluatorParameterName, "The operator used to evaluate a solution."));
-      Parameters.Add(new ValueParameter<U>(SolutionCreateParameterName, "The operator to create a solution."));
       RegisterEventHandlers();
     }
 
-    protected HeuristicOptimizationProblem(T evaluator, U solutionCreator)
+    protected HeuristicOptimizationProblem(T evaluator)
       : base() {
       Parameters.Add(new ValueParameter<T>(EvaluatorParameterName, "The operator used to evaluate a solution.", evaluator));
-      Parameters.Add(new ValueParameter<U>(SolutionCreateParameterName, "The operator to create a solution.", solutionCreator));
       RegisterEventHandlers();
     }
@@ -63 +59 @@
     private void RegisterEventHandlers() {
       EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
-      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
     }
 
@@ -76 +71 @@
     IEvaluator IHeuristicOptimizationProblem.Evaluator { get { return Evaluator; } }
     IParameter IHeuristicOptimizationProblem.EvaluatorParameter { get { return EvaluatorParameter; } }
-
-    public U SolutionCreator {
-      get { return (U)SolutionCreatorParameter.Value; }
-      protected set { SolutionCreatorParameter.Value = value; }
-    }
-    public IValueParameter SolutionCreatorParameter {
-      get { return (IValueParameter)Parameters[SolutionCreateParameterName]; }
-    }
-    ISolutionCreator IHeuristicOptimizationProblem.SolutionCreator { get { return SolutionCreator; } }
-    IParameter IHeuristicOptimizationProblem.SolutionCreatorParameter { get { return SolutionCreatorParameter; } }
     #endregion
 
@@ -98 +83 @@
         handler(this, EventArgs.Empty);
     }
-
-    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
-      OnSolutionCreatorChanged();
-    }
-    public event EventHandler SolutionCreatorChanged;
-    protected virtual void OnSolutionCreatorChanged() {
-      EventHandler handler = SolutionCreatorChanged;
-      if (handler != null)
-        handler(this, EventArgs.Empty);
-    }
     #endregion
   }

branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Problems/MultiObjectiveHeuristicOptimizationProblem.cs

@@ -30 +30 @@
   [Item("Multi-Objective Heuristic Optimization Problem", "A base class for multi-objective heuristic optimization problems.")]
   [StorableType("C46643E3-7144-4884-A30A-5329BD80DC4E")]
-  public abstract class MultiObjectiveHeuristicOptimizationProblem<T, U> : HeuristicOptimizationProblem<T, U>, IMultiObjectiveHeuristicOptimizationProblem
-    where T : class, IMultiObjectiveEvaluator
-    where U : class, ISolutionCreator {
+  public abstract class MultiObjectiveHeuristicOptimizationProblem<T> : HeuristicOptimizationProblem<T>, IMultiObjectiveHeuristicOptimizationProblem
+    where T : class, IMultiObjectiveEvaluator {
     private const string MaximizationParameterName = "Maximization";
 
     [StorableConstructor]
     protected MultiObjectiveHeuristicOptimizationProblem(StorableConstructorFlag _) : base(_) { }
-    protected MultiObjectiveHeuristicOptimizationProblem(MultiObjectiveHeuristicOptimizationProblem<T, U> original, Cloner cloner)
+    protected MultiObjectiveHeuristicOptimizationProblem(MultiObjectiveHeuristicOptimizationProblem<T> original, Cloner cloner)
       : base(original, cloner) {
       RegisterEventHandlers();
@@ -48 +47 @@
     }
 
-    protected MultiObjectiveHeuristicOptimizationProblem(T evaluator, U solutionCreator)
-      : base(evaluator, solutionCreator) {
+    protected MultiObjectiveHeuristicOptimizationProblem(T evaluator)
+      : base(evaluator) {
       Parameters.Add(new ValueParameter<BoolArray>(MaximizationParameterName, "Determines for each objective whether it should be maximized or minimized."));
 

branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Problems/SingleObjectiveHeuristicOptimizationProblem.cs

@@ -30 +30 @@
   [Item("Single-Objective Heuristic OptimizationProblem", "A base class for single-objective heuristic optimization problems.")]
   [StorableType("DFD5588E-6AB2-4712-9083-A405EF21226F")]
-  public abstract class SingleObjectiveHeuristicOptimizationProblem<T, U> : HeuristicOptimizationProblem<T, U>, ISingleObjectiveHeuristicOptimizationProblem
-    where T : class, ISingleObjectiveEvaluator
-    where U : class, ISolutionCreator {
+  public abstract class SingleObjectiveHeuristicOptimizationProblem<T> : HeuristicOptimizationProblem<T>, ISingleObjectiveHeuristicOptimizationProblem
+    where T : class, ISingleObjectiveEvaluator {
     private const string MaximizationParameterName = "Maximization";
     private const string BestKnownQualityParameterName = "BestKnownQuality";
@@ -38 +37 @@
     [StorableConstructor]
     protected SingleObjectiveHeuristicOptimizationProblem(StorableConstructorFlag _) : base(_) { }
-    protected SingleObjectiveHeuristicOptimizationProblem(SingleObjectiveHeuristicOptimizationProblem<T, U> original, Cloner cloner)
+    protected SingleObjectiveHeuristicOptimizationProblem(SingleObjectiveHeuristicOptimizationProblem<T> original, Cloner cloner)
       : base(original, cloner) {
       RegisterEventHandlers();
@@ -50 +49 @@
     }
 
-    protected SingleObjectiveHeuristicOptimizationProblem(T evaluator, U solutionCreator)
-      : base(evaluator, solutionCreator) {
+    protected SingleObjectiveHeuristicOptimizationProblem(T evaluator)
+      : base(evaluator) {
       Parameters.Add(new ValueParameter<BoolValue>(MaximizationParameterName, "Set to false if the problem should be minimized.", new BoolValue()));
       Parameters.Add(new OptionalValueParameter<DoubleValue>(BestKnownQualityParameterName, "The quality of the best known solution of this problem."));

branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Problems/UserDefinedProblem.cs

@@ -62 +62 @@
       get { return MaximizationParameter; }
     }
-    public ValueParameter<ISolutionCreator> SolutionCreatorParameter {
-      get { return (ValueParameter<ISolutionCreator>)Parameters["SolutionCreator"]; }
-    }
-    IParameter IHeuristicOptimizationProblem.SolutionCreatorParameter {
-      get { return SolutionCreatorParameter; }
-    }
     IParameter IHeuristicOptimizationProblem.EvaluatorParameter {
       get { return EvaluatorParameter; }
@@ -89 +83 @@
       get { return MaximizationParameter.Value; }
       set { MaximizationParameter.Value = value; }
-    }
-    public ISolutionCreator SolutionCreator {
-      get { return SolutionCreatorParameter.Value; }
-      set { SolutionCreatorParameter.Value = value; }
-    }
-    ISolutionCreator IHeuristicOptimizationProblem.SolutionCreator {
-      get { return SolutionCreatorParameter.Value; }
     }
     public ISingleObjectiveEvaluator Evaluator {
@@ -138 +125 @@
       : base() {
       Parameters.Add(new ValueParameter<ISingleObjectiveEvaluator>("Evaluator", "The evaluator that collects the values to exchange.", new EmptyUserDefinedProblemEvaluator()));
-      Parameters.Add(new ValueParameter<ISolutionCreator>("SolutionCreator", "An operator to create the solution components."));
       Parameters.Add(new ValueParameter<BoolValue>("Maximization", "Set to false as most test functions are minimization problems.", new BoolValue(false)));
       Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
@@ -156 +142 @@
 
     #region Events
-    public event EventHandler SolutionCreatorChanged;
-    private void OnSolutionCreatorChanged() {
-      EventHandler handler = SolutionCreatorChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
     public event EventHandler EvaluatorChanged;
     private void OnEvaluatorChanged() {
@@ -174 +155 @@
 
     #region Event handlers
-    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
-      OnSolutionCreatorChanged();
-    }
     private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
       if (Evaluator != null)
@@ -202 +180 @@
     #region Helpers
     private void RegisterEventHandlers() {
-      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
       EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
       if (Evaluator != null)