Changeset 13356

Timestamp:

11/24/15 12:56:04 (8 years ago)

Author:

abeham

Message:

#2521: working on multi-encoding

Location:

branches/ProblemRefactoring

Files:

• HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiSolution.cs (modified) (4 diffs)
• HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiEncodingOperator.cs (modified) (1 diff)
• HeuristicLab.Optimization/3.3/BasicProblems/MultiEncoding.cs (modified) (4 diffs)
• HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCreator.cs (modified) (5 diffs)
• HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCrossover.cs (modified) (2 diffs)
• HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingManipulator.cs (modified) (1 diff)
• HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingOperator.cs (modified) (4 diffs)
• HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj (modified) (2 diffs)
• HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblems.cs (modified) (1 diff)
• HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblems.cs (modified) (1 diff)

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiSolution.cs

@@ -28 +28 @@
 
 namespace HeuristicLab.Optimization {
-  [Item("MultiSolution", "A solution that consists of other solutions.")]
+  [Item("CombinedSolution", "A solution that consists of other solutions.")]
   [StorableClass]
-  public sealed class MultiSolution : Item, ISolution {
+  public sealed class CombinedSolution : Item, ISolution {
 
     private MultiEncoding Encoding { get; set; }
@@ -38 +38 @@
 
     [StorableConstructor]
-    private MultiSolution(bool deserializing) : base(deserializing) { }
+    private CombinedSolution(bool deserializing) : base(deserializing) { }
 
-    private MultiSolution(MultiSolution original, Cloner cloner)
+    private CombinedSolution(CombinedSolution original, Cloner cloner)
       : base(original, cloner) {
       Encoding = cloner.Clone(original.Encoding);
@@ -46 +46 @@
       solutions = original.solutions.ToDictionary(x => x.Key, x => cloner.Clone(x.Value));
     }
-    public MultiSolution(MultiEncoding encoding, IScope scope) {
+    public CombinedSolution(IScope scope, MultiEncoding encoding) {
       Encoding = encoding;
       Scope = scope;
@@ -54 +54 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiSolution(this, cloner);
+      return new CombinedSolution(this, cloner);
     }
 

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

@@ -24 +24 @@
 namespace HeuristicLab.Optimization {
   public interface IMultiEncodingOperator : IOperator {
-    void AddEncoding(IEncoding encoding);
-    bool RemoveEncoding(IEncoding encoding);
+    MultiEncoding Encoding { get; set; }
   }
 }

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

@@ -31 +31 @@
   [Item("MultiEncoding", "Describes a combined encoding consisting of multiple simpler encodings.")]
   [StorableClass]
-  public sealed class MultiEncoding : Encoding<MultiSolution> {
+  public sealed class MultiEncoding : Encoding<CombinedSolution> {
 
-    private readonly List<IEncoding> encodings;
+    private readonly ItemCollection<IEncoding> encodings;
+
     [Storable]
-    public IEnumerable<IEncoding> Encodings {
+    private IEnumerable<IEncoding> StorableEncodings {
       get { return encodings; }
-      private set { encodings.AddRange(value); }
+      set { encodings.AddRange(value); }
+    }
+
+    public ReadOnlyItemCollection<IEncoding> Encodings {
+      get { return encodings.AsReadOnly(); }
     }
 
@@ -43 +48 @@
     private MultiEncoding(bool deserializing)
       : base(deserializing) {
-      encodings = new List<IEncoding>();
+      encodings = new ItemCollection<IEncoding>();
     }
     public override IDeepCloneable Clone(Cloner cloner) { return new MultiEncoding(this, cloner); }
     private MultiEncoding(MultiEncoding original, Cloner cloner)
       : base(original, cloner) {
-      encodings = new List<IEncoding>(original.Encodings.Select(cloner.Clone));
+      encodings = new ItemCollection<IEncoding>(original.Encodings.Select(cloner.Clone));
     }
     public MultiEncoding()
       : base("MultiEncoding") {
-      encodings = new List<IEncoding>();
-      SolutionCreator = new MultiEncodingCreator();
-
-      foreach (var @operator in ApplicationManager.Manager.GetInstances<IMultiEncodingOperator>())
+      encodings = new ItemCollection<IEncoding>();
+      SolutionCreator = new MultiEncodingCreator() { Encoding = this };
+      foreach (var @operator in ApplicationManager.Manager.GetInstances<IMultiEncodingOperator>()) {
+        @operator.Encoding = this;
         AddOperator(@operator);
+      }
     }
 
@@ -63 +69 @@
       if (Encodings.Any(e => e.Name == encoding.Name)) throw new ArgumentException("Encoding name must be unique", "encoding.Name");
       encodings.Add(encoding);
-
       Parameters.AddRange(encoding.Parameters);
-
-      foreach (var @operator in Operators.OfType<IMultiEncodingOperator>()) {
-        @operator.AddEncoding(encoding);
-      }
-      OnEncodingsChanged();
       return this;
     }
@@ -76 +76 @@
       var success = encodings.Remove(encoding);
       Parameters.RemoveRange(encoding.Parameters);
-      foreach (var @operator in Operators.OfType<IMultiEncodingOperator>()) {
-        @operator.RemoveEncoding(encoding);
-      }
-      OnEncodingsChanged();
       return success;
     }
 
-    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
-    }
-
-    public event EventHandler EncodingsChanged;
-    private void OnEncodingsChanged() {
-      var handler = EncodingsChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) { }
   }
 }

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCreator.cs

@@ -24 +24 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -29 +30 @@
   [Item("MultiEncodingCreator", "Contains solution creators that together create a multi-encoding.")]
   [StorableClass]
-  public sealed class MultiEncodingCreator : MultiEncodingOperator<ISolutionCreator>, ISolutionCreator<MultiSolution> {
+  public sealed class MultiEncodingCreator : MultiEncodingOperator<ISolutionCreator>, ISolutionCreator<CombinedSolution> {
+
     [StorableConstructor]
     private MultiEncodingCreator(bool deserializing) : base(deserializing) { }
     private MultiEncodingCreator(MultiEncodingCreator original, Cloner cloner) : base(original, cloner) { }
-    public MultiEncodingCreator() { }
+    public MultiEncodingCreator() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -39 +41 @@
     }
 
-    public override void AddEncoding(IEncoding encoding) {
+    protected override void AddEncoding(IEncoding encoding) {
       base.AddEncoding(encoding);
       var parameter = GetParameter(encoding);
@@ -46 +48 @@
     }
 
-    public override bool RemoveEncoding(IEncoding encoding) {
+    protected override bool RemoveEncoding(IEncoding encoding) {
       var success = base.RemoveEncoding(encoding);
       encoding.SolutionCreatorChanged -= Encoding_SolutionCreatorChanged;
@@ -61 +63 @@
       parameter.Value = encoding.SolutionCreator;
     }
+
+
+    public override IOperation InstrumentedApply() {
+      CombinedSolutionParameter.ActualValue = new CombinedSolution(ExecutionContext.Scope, Encoding);
+      return base.Apply();
+    }
   }
 }

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingCrossover.cs

@@ -22 +22 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -28 +29 @@
   [StorableClass]
   public sealed class MultiEncodingCrossover : MultiEncodingOperator<ICrossover>, ICrossover {
+
     [StorableConstructor]
     private MultiEncodingCrossover(bool deserializing) : base(deserializing) { }
     private MultiEncodingCrossover(MultiEncodingCrossover original, Cloner cloner) : base(original, cloner) { }
-    public MultiEncodingCrossover() { }
+    public MultiEncodingCrossover() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) { return new MultiEncodingCrossover(this, cloner); }
+
+
+    public override IOperation InstrumentedApply() {
+      CombinedSolutionParameter.ActualValue = new CombinedSolution(ExecutionContext.Scope, Encoding);
+      return base.Apply();
+    }
   }
 }

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingManipulator.cs

@@ -30 +30 @@
     [StorableConstructor]
     private MultiEncodingManipulator(bool deserializing) : base(deserializing) { }
-    private MultiEncodingManipulator(MultiEncodingManipulator original, Cloner cloner)
-      : base(original, cloner) { }
-    public MultiEncodingManipulator() { }
+    private MultiEncodingManipulator(MultiEncodingManipulator original, Cloner cloner) : base(original, cloner) { }
+    public MultiEncodingManipulator() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) { return new MultiEncodingManipulator(this, cloner); }

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiEncodingOperator.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
+using HeuristicLab.Collections;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -31 +32 @@
 namespace HeuristicLab.Optimization {
   [StorableClass]
-  public abstract class MultiEncodingOperator<T> : Operator, IMultiEncodingOperator where T : class, IOperator {
-    private List<IEncoding> encodings = new List<IEncoding>();
-    [Storable(Name = "Encodings")]
-    private IEnumerable<IEncoding> StorableEncodings {
-      get { return encodings; }
-      set { encodings = new List<IEncoding>(value); }
+  public abstract class MultiEncodingOperator<T> : InstrumentedOperator, IMultiEncodingOperator where T : class, IOperator {
+    [Storable]
+    private MultiEncoding encoding;
+    public MultiEncoding Encoding {
+      get { return encoding; }
+      set {
+        if (value == null) throw new ArgumentNullException("Encoding must not be null.");
+        if (value == encoding) return;
+        if (encoding != null) DeregisterEventHandlers();
+        encoding = value;
+        CombinedSolutionParameter.ActualName = encoding.Name;
+        RegisterEventHandlers();
+      }
+    }
+
+    public ILookupParameter<CombinedSolution> CombinedSolutionParameter {
+      get { return (ILookupParameter<CombinedSolution>)Parameters["CombinedSolution"]; }
     }
 
     [StorableConstructor]
-    protected MultiEncodingOperator(bool deserializing)
-      : base(deserializing) {
-    }
-
+    protected MultiEncodingOperator(bool deserializing) : base(deserializing) { }
     protected MultiEncodingOperator(MultiEncodingOperator<T> original, Cloner cloner)
       : base(original, cloner) {
-      encodings = new List<IEncoding>(original.encodings.Select(cloner.Clone));
-      foreach (var encoding in encodings)
-        encoding.OperatorsChanged += Encoding_OperatorsChanged;
+      encoding = cloner.Clone(original.encoding);
+      RegisterEventHandlers();
     }
-
-    protected MultiEncodingOperator() : base() { }
+    protected MultiEncodingOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<CombinedSolution>("CombinedSolution", "The combined solution that gets created."));
+    }
 
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      foreach (var encoding in encodings)
-        encoding.OperatorsChanged += Encoding_OperatorsChanged;
+      RegisterEventHandlers();
     }
 
+    private void RegisterEventHandlers() {
+      encoding.Encodings.ItemsAdded += EncodingsOnItemsChanged;
+      encoding.Encodings.CollectionReset += EncodingsOnItemsChanged;
+      encoding.Encodings.ItemsRemoved += EncodingsOnItemsRemoved;
+      foreach (var enc in encoding.Encodings)
+        enc.OperatorsChanged += Encoding_OperatorsChanged;
+    }
 
-    public override IOperation Apply() {
+    private void DeregisterEventHandlers() {
+      encoding.Encodings.ItemsAdded -= EncodingsOnItemsChanged;
+      encoding.Encodings.CollectionReset -= EncodingsOnItemsChanged;
+      encoding.Encodings.ItemsRemoved -= EncodingsOnItemsRemoved;
+      foreach (var enc in encoding.Encodings)
+        enc.OperatorsChanged -= Encoding_OperatorsChanged;
+    }
+
+    private void EncodingsOnItemsChanged(object sender, CollectionItemsChangedEventArgs<IEncoding> e) {
+      foreach (var enc in e.Items)
+        AddEncoding(enc);
+      foreach (var enc in e.OldItems)
+        RemoveEncoding(enc);
+    }
+
+    private void EncodingsOnItemsRemoved(object sender, CollectionItemsChangedEventArgs<IEncoding> e) {
+      foreach (var enc in e.Items)
+        RemoveEncoding(enc);
+    }
+
+    public override IOperation InstrumentedApply() {
       var operations = Parameters.Select(p => p.ActualValue).OfType<IOperator>().Select(op => ExecutionContext.CreateOperation(op));
       return new OperationCollection(operations);
     }
 
-    public virtual void AddEncoding(IEncoding encoding) {
+    protected virtual void AddEncoding(IEncoding encoding) {
       if (Parameters.ContainsKey(encoding.Name)) throw new ArgumentException(string.Format("Encoding {0} was already added.", encoding.Name));
 
-      encodings.Add(encoding);
       encoding.OperatorsChanged += Encoding_OperatorsChanged;
 
@@ -76 +111 @@
     }
 
-    public virtual bool RemoveEncoding(IEncoding encoding) {
-      if (!encodings.Remove(encoding)) throw new ArgumentException(string.Format("Encoding {0} was not added to the MultiEncoding.", encoding.Name));
+    protected virtual bool RemoveEncoding(IEncoding encoding) {
+      if (!Parameters.ContainsKey(encoding.Name)) throw new ArgumentException(string.Format("Encoding {0} was not added to the MultiEncoding.", encoding.Name));
       encoding.OperatorsChanged -= Encoding_OperatorsChanged;
       return Parameters.Remove(encoding.Name);
@@ -89 +124 @@
 
     private void Encoding_OperatorsChanged(object sender, EventArgs e) {
-      var encoding = (IEncoding)sender;
-      var param = GetParameter(encoding);
+      var enc = (IEncoding)sender;
+      var param = GetParameter(enc);
 
       var oldParameterValue = param.Value;
       param.ValidValues.Clear();
-      foreach (var op in encoding.Operators.OfType<T>())
+      foreach (var op in enc.Operators.OfType<T>())
         param.ValidValues.Add(op);
 

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj

@@ -122 +122 @@
     <Compile Include="Algorithms\BasicAlgorithm.cs" />
     <Compile Include="BasicProblems\Individuals\MultiSolution.cs" />
+    <Compile Include="BasicProblems\Interfaces\IMultiEncodingOperator.cs" />
     <Compile Include="BasicProblems\Interfaces\ISingleObjectiveProblem.cs" />
     <Compile Include="BasicProblems\MultiEncoding.cs" />
@@ -132 +133 @@
     <Compile Include="BasicProblems\Interfaces\IEncoding.cs" />
     <Compile Include="BasicProblems\Interfaces\IEncodingOperator.cs" />
-    <Compile Include="BasicProblems\Interfaces\IMultiEncodingOperator.cs" />
     <Compile Include="BasicProblems\Interfaces\IMultiObjectiveProblemDefinition.cs" />
     <Compile Include="BasicProblems\Interfaces\internal\IMultiObjectiveAnalysisOperator.cs" />

branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblems.cs

@@ -56 +56 @@
   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
   [StorableClass]
-  public sealed class MultiObjectiveMultiSolutionProgrammableProblem : MultiObjectiveProgrammableProblem<MultiEncoding, MultiSolution> {
+  public sealed class MultiObjectiveMultiSolutionProgrammableProblem : MultiObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
 
     [StorableConstructor]

branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblems.cs

@@ -56 +56 @@
   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
   [StorableClass]
-  public sealed class SingleObjectiveMultiSolutionProgrammableProblem : SingleObjectiveProgrammableProblem<MultiEncoding, MultiSolution> {
+  public sealed class SingleObjectiveMultiSolutionProgrammableProblem : SingleObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
 
     [StorableConstructor]