Changeset 11753 for branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/ProgrammableProblem.cs

Timestamp:

01/13/15 18:47:19 (9 years ago)

Author:

mkommend

Message:

#2174: First working version of refactored programmable problem.

File:

• branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/ProgrammableProblem.cs (modified) (7 diffs)

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/ProgrammableProblem.cs

@@ -28 +28 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Programmable.Interfaces;
 
 namespace HeuristicLab.Problems.Programmable {
@@ -46 +47 @@
       protected set {
         if (value == null) throw new ArgumentNullException("Encoding must not be null.");
-        if (Encoding != null) Parameters.RemoveRange(Encoding.Parameters);
         EncodingParameter.Value = value;
-        Parameters.AddRange(Encoding.Parameters);
       }
     }
+    //mkommend necessary for reuse of operators if the encoding changes
+    private TEncoding oldEncoding;
 
     public virtual IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
@@ -57 +58 @@
 
     protected override IEnumerable<IItem> GetOperators() {
+      if (Encoding == null) return base.GetOperators();
       return base.GetOperators().Concat(Encoding.Operators);
     }
     public override IEnumerable<IParameterizedItem> ExecutionContextItems {
-      get { return base.ExecutionContextItems.Concat(new[] { Encoding }); }
+      get {
+        if (Encoding == null) return base.ExecutionContextItems;
+        return base.ExecutionContextItems.Concat(new[] { Encoding });
+      }
     }
 
-    public ProgrammableProblem()
+    protected ProgrammableProblem()
       : 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."));
+      oldEncoding = Encoding;
       RegisterEvents();
     }
@@ -71 +77 @@
     protected ProgrammableProblem(ProgrammableProblem<TEncoding, TEvaluator> original, Cloner cloner)
       : base(original, cloner) {
+      oldEncoding = cloner.Clone(original.oldEncoding);
       RegisterEvents();
     }
 
     [StorableConstructor]
-    protected ProgrammableProblem(bool deserializing)
-      : base(deserializing) {
+    protected ProgrammableProblem(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      oldEncoding = Encoding;
       RegisterEvents();
     }
@@ -85 +94 @@
 
     protected virtual void OnEncodingChanged() {
+      if (oldEncoding != null) AdaptEncodingOperators(oldEncoding, Encoding);
+      oldEncoding = Encoding;
+
       var solutionCreatorType = Encoding.GetType().BaseType.GetGenericArguments();
       var paramType = typeof(ValueParameter<>).MakeGenericType(solutionCreatorType);
@@ -91 +103 @@
       Parameters.Remove(SolutionCreatorParameter);
       Parameters.Add(solutionCreatorParam);
+
+      OnOperatorsChanged();
+      OnReset();
     }
 
@@ -106 +121 @@
     }
 
+    private static void AdaptEncodingOperators(IEncoding oldEncoding, IEncoding newEncoding) {
+      if (oldEncoding.GetType() != newEncoding.GetType()) return;
+
+      if (oldEncoding.GetType() == typeof(MultiEncoding)) {
+        var oldMultiEncoding = (MultiEncoding)oldEncoding;
+        var newMultiEncoding = (MultiEncoding)newEncoding;
+        if (!oldMultiEncoding.Encodings.SequenceEqual(newMultiEncoding.Encodings, new TypeEqualityComparer<IEncoding>())) return;
+
+        var nestedEncodings = oldMultiEncoding.Encodings.Zip(newMultiEncoding.Encodings, (o, n) => new { oldEnc = o, newEnc = n });
+        foreach (var multi in nestedEncodings)
+          AdaptEncodingOperators(multi.oldEnc, multi.newEnc);
+
+        foreach (var op in oldMultiEncoding.Operators.OfType<IMultiEncodingOperator>())
+          foreach (var multi in nestedEncodings)
+            op.ReplaceEncoding(multi.oldEnc, multi.newEnc);
+      }
+
+      var comparer = new TypeEqualityComparer<IOperator>();
+      var oldOperators = oldEncoding.Operators;
+      var newOperators = newEncoding.Operators;
+
+      var operators = oldOperators.Intersect(newOperators, comparer);
+      operators = operators.Union(newOperators, comparer);
+
+      newEncoding.ConfigureOperators(operators);
+      newEncoding.Operators = operators;
+    }
+
   }
 }