Changeset 13469 for branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems

Timestamp:

12/15/15 15:16:24 (9 years ago)

Author:

mkommend

Message:

#2521: Refactored problem base classes and adapted scheduling encoding, scheduling problem and unit tests.

Location:

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems

Files:

• Encoding.cs (modified) (2 diffs)
• Interfaces/IEncoding.cs (modified) (2 diffs)
• Problem.cs (modified) (6 diffs)

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs

@@ -53 +53 @@
         foreach (var op in value) encodingOperators.Add(op);
 
-        ISolutionCreator<TSolution> newSolutionCreator = (ISolutionCreator<TSolution>)encodingOperators.FirstOrDefault(o => o.GetType() == solutionCreator.GetType()) ??
+        ISolutionCreator<TSolution> newSolutionCreator = (ISolutionCreator<TSolution>)encodingOperators.FirstOrDefault(o => o.GetType() == SolutionCreator.GetType()) ??
                                encodingOperators.OfType<ISolutionCreator<TSolution>>().First();
         SolutionCreator = newSolutionCreator;
@@ -60 +60 @@
     }
 
-    ISolutionCreator IEncoding.SolutionCreator {
-      get { return solutionCreator; }
+    public IValueParameter SolutionCreatorParameter {
+      get { return (IValueParameter)Parameters[Name + ".SolutionCreator"]; }
     }
 
-    [Storable]
-    private ISolutionCreator<TSolution> solutionCreator;
+    ISolutionCreator IEncoding.SolutionCreator {
+      get { return SolutionCreator; }
+    }
     public ISolutionCreator<TSolution> SolutionCreator {
-      get {
-        return solutionCreator;
-      }
+      get { return (ISolutionCreator<TSolution>)SolutionCreatorParameter.Value; }
       set {
         if (value == null) throw new ArgumentNullException("SolutionCreator must not be null.");
-        if (solutionCreator == value) return;
-        encodingOperators.Remove(solutionCreator);
+        encodingOperators.Remove(SolutionCreator);
         encodingOperators.Add(value);
-        solutionCreator = value;
+        SolutionCreatorParameter.Value = value;
         OnSolutionCreatorChanged();
       }
     }
 
+
     [StorableConstructor]
     protected Encoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
     protected Encoding(Encoding<TSolution> original, Cloner cloner)
       : base(original, cloner) {
       encodingOperators = cloner.Clone(original.encodingOperators);
-      solutionCreator = cloner.Clone(original.solutionCreator);
+
+      RegisterEventHandlers();
     }
+
     protected Encoding(string name)
       : base(name) {
+      Parameters.Add(new ValueParameter<ISolutionCreator<TSolution>>(name + ".SolutionCreator", "The operator to create a solution."));
       Parameters.Add(new FixedValueParameter<ReadOnlyItemSet<IOperator>>(name + ".Operators", "The operators that the encoding specifies.", encodingOperators.AsReadOnly()));
+
+      RegisterEventHandlers();
+    }
+
+    private void RegisterEventHandlers() {
+      SolutionCreatorParameter.ValueChanged += (o, e) => OnSolutionCreatorChanged();
     }
 

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs

@@ -26 +26 @@
 namespace HeuristicLab.Optimization {
   public interface IEncoding : IParameterizedNamedItem {
+    IValueParameter SolutionCreatorParameter { get; }
     ISolutionCreator SolutionCreator { get; }
+
     IEnumerable<IOperator> Operators { get; set; }
 
@@ -32 +34 @@
     void ConfigureOperators(IEnumerable<IItem> operators);
 
+    event EventHandler OperatorsChanged;
     event EventHandler SolutionCreatorChanged;
-    event EventHandler OperatorsChanged;
   }
 
   public interface IEncoding<TSolution> : IEncoding
     where TSolution : class, ISolution {
-    new ISolutionCreator<TSolution> SolutionCreator { get; set; }
+    //new ISolutionCreator<TSolution> SolutionCreator { get; }
   }
 }

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs

@@ -30 +30 @@
 namespace HeuristicLab.Optimization {
   [StorableClass]
-  public abstract class Problem<TEncoding, TSolution, TEvaluator> : HeuristicOptimizationProblem<TEvaluator, ISolutionCreator<TSolution>>, IProblemDefinition<TEncoding, TSolution>, IStorableContent
+  public abstract class Problem<TEncoding, TSolution, TEvaluator> : Problem,
+    IHeuristicOptimizationProblem, IProblemDefinition<TEncoding, TSolution>, IStorableContent
     where TEncoding : class, IEncoding<TSolution>
     where TSolution : class, ISolution
     where TEvaluator : class, IEvaluator {
 
-    public string Filename { get; set; } // TODO: Really okay here?
+    public string Filename { get; set; } // TODO: Really okay here? should be in Problem (non-generic)
 
+    //TODO remove parametr for encoding?
     protected IValueParameter<TEncoding> EncodingParameter {
       get { return (IValueParameter<TEncoding>)Parameters["Encoding"]; }
     }
-
     //mkommend necessary for reuse of operators if the encoding changes
     private TEncoding oldEncoding;
-
     public TEncoding Encoding {
       get { return EncodingParameter.Value; }
@@ -51 +51 @@
       }
     }
+
+    ISolutionCreator IHeuristicOptimizationProblem.SolutionCreator {
+      get { return Encoding.SolutionCreator; }
+    }
+    IParameter IHeuristicOptimizationProblem.SolutionCreatorParameter {
+      get { return Encoding.SolutionCreatorParameter; }
+    }
+    event EventHandler IHeuristicOptimizationProblem.SolutionCreatorChanged {
+      add { Encoding.SolutionCreatorChanged += value; }
+      remove { Encoding.SolutionCreatorChanged -= value; }
+    }
+
+    //TODO is a parameter for the evaluator really necessary, only single-objective or multi-objective evulators calling the func are possible
+    public ValueParameter<TEvaluator> EvaluatorParameter {
+      get { return (ValueParameter<TEvaluator>)Parameters["Evaluator"]; }
+    }
+    public TEvaluator Evaluator {
+      get { return EvaluatorParameter.Value; }
+      protected set { EvaluatorParameter.Value = value; }
+    }
+    IEvaluator IHeuristicOptimizationProblem.Evaluator { get { return Evaluator; } }
+    IParameter IHeuristicOptimizationProblem.EvaluatorParameter { get { return EvaluatorParameter; } }
+
+    public event EventHandler EvaluatorChanged;
+    protected virtual void OnEvaluatorChanged() {
+      EventHandler handler = EvaluatorChanged;
+      if (handler != null)
+        handler(this, EventArgs.Empty);
+    }
+
 
     protected override IEnumerable<IItem> GetOperators() {
@@ -66 +96 @@
       : base() {
       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."));
+      Parameters.Add(new ValueParameter<TEvaluator>("Evaluator", "The operator used to evaluate a solution."));
+
       if (Encoding != null) {
         oldEncoding = Encoding;
-        SolutionCreator = Encoding.SolutionCreator;
         Parameterize();
       }
@@ -76 +107 @@
       if (encoding == null) throw new ArgumentNullException("encoding");
       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));
+      Parameters.Add(new ValueParameter<TEvaluator>("Evaluator", "The operator used to evaluate a solution."));
+
       oldEncoding = Encoding;
-      SolutionCreator = Encoding.SolutionCreator;
       Parameterize();
 
@@ -99 +131 @@
     private void RegisterEvents() {
       EncodingParameter.ValueChanged += (o, e) => OnEncodingChanged();
+      EvaluatorParameter.ValueChanged += (o, e) => OnEvaluatorChanged();
       //var multiEncoding = Encoding as MultiEncoding;
       //if (multiEncoding != null) multiEncoding.EncodingsChanged += MultiEncodingOnEncodingsChanged;
@@ -122 +155 @@
         op.EncodingParameter.ActualName = EncodingParameter.Name;
 
-      SolutionCreator = Encoding.SolutionCreator;
-
       //var multiEncoding = Encoding as MultiEncoding;
       //if (multiEncoding != null) multiEncoding.EncodingsChanged += MultiEncodingOnEncodingsChanged;
     }
 
-    protected override void OnSolutionCreatorChanged() {
-      base.OnSolutionCreatorChanged();
-      Encoding.SolutionCreator = SolutionCreator;
-    }
+    //protected override void OnSolutionCreatorChanged() {
+    //  base.OnSolutionCreatorChanged();
+    //  Encoding.SolutionCreator = SolutionCreator;
+    //}
 
     private static void AdaptEncodingOperators(IEncoding oldEncoding, IEncoding newEncoding) {
       if (oldEncoding.GetType() != newEncoding.GetType()) return;
 
-      if (oldEncoding.GetType() == typeof(CombinedEncoding)) {
+      if (oldEncoding is CombinedEncoding) {
         var oldMultiEncoding = (CombinedEncoding)oldEncoding;
         var newMultiEncoding = (CombinedEncoding)newEncoding;