Changeset 11553 for branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings

Timestamp:

11/15/14 17:30:02 (10 years ago)

Author:

mkommend

Message:

#2174: Adapted binary encoding to new wiring method.

Location:

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings

Files:

• BinaryEncoding.cs (modified) (1 diff)
• Encoding.cs (modified) (3 diffs)
• RealEncoding.cs (modified) (2 diffs)

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/BinaryEncoding.cs

@@ -20 +20 @@
 #endregion
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.Programmable {
   [Item("BinaryEncoding", "Describes a binary vector encoding.")]
   [StorableClass]
-  public class BinaryEncoding : Encoding {
+  public sealed class BinaryEncoding : Encoding {
+    #region Encoding Parameters
     [Storable]
-    private IntValue length;
-    public IntValue Length {
-      get { return length; }
+    private IFixedValueParameter<IntValue> lengthParameter;
+    public IFixedValueParameter<IntValue> LengthParameter {
+      get { return lengthParameter; }
       set {
-        if (length == value) return;
-        length = value;
-        OnParameterConfigurationChanged();
+        if (value == null) throw new ArgumentNullException("Length parameter must not be null.");
+        if (lengthParameter == value) return;
+        lengthParameter = value;
+        OnLengthParameterChanged();
       }
+    }
+    public override IEnumerable<IValueParameter> Parameters {
+      get { return base.Parameters.Concat(new IValueParameter[] { LengthParameter }); }
+    }
+    #endregion
+
+    private List<IOperator> encodingOperators = new List<IOperator>();
+    [Storable]
+    public override IEnumerable<IOperator> Operators {
+      get { return encodingOperators; }
+      protected set { encodingOperators = new List<IOperator>(value); }
+    }
+
+    public override ISolutionCreator DefaultSolutionCreator {
+      get { return Operators.OfType<RandomBinaryVectorCreator>().First(); }
+    }
+
+    public int Length {
+      get { return LengthParameter.Value.Value; }
+      set { LengthParameter.Value.Value = value; }
     }
 
     [StorableConstructor]
-    protected BinaryEncoding(bool deserializing) : base(deserializing) { }
-    protected BinaryEncoding(BinaryEncoding original, Cloner cloner)
+    private BinaryEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new BinaryEncoding(this, cloner); }
+    private BinaryEncoding(BinaryEncoding original, Cloner cloner)
       : base(original, cloner) {
-      length = cloner.Clone(original.length);
+      lengthParameter = cloner.Clone(original.lengthParameter);
+      encodingOperators = original.Operators.Select(cloner.Clone).ToList();
+      RegisterParameterEvents();
     }
     public BinaryEncoding(string name, int length)
       : base(name) {
-      this.length = new IntValue(length);
+      lengthParameter = new FixedValueParameter<IntValue>(Name + "Length", new IntValue(length));
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new BinaryEncoding(this, cloner);
+    private void OnLengthParameterChanged() {
+      RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void RegisterParameterEvents() {
+      RegisterLengthParameterEvents();
+    }
+    private void RegisterLengthParameterEvents() {
+      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
     }
 
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static BinaryEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+        typeof (IBinaryVectorOperator),
+        typeof (IBinaryVectorCreator),
+        typeof (IBinaryVectorCrossover),
+        typeof (IBinaryVectorManipulator),
+        typeof (IBinaryVectorMoveOperator),
+        typeof (IBinaryVectorMultiNeighborhoodShakingOperator),
+      };
+    }
+    private void DiscoverOperators() {
+      var pluginDescription = ApplicationManager.Manager.GetDeclaringPlugin(typeof(IBinaryVectorOperator));
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, pluginDescription, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(encodingOperators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      encodingOperators.AddRange(newOperators);
+    }
+    #endregion
+
+    public void ConfigureOperators(IEnumerable<IOperator> operators) {
+      ConfigureCreators(operators.OfType<IBinaryVectorCreator>());
+      ConfigureCrossovers(operators.OfType<IBinaryVectorCrossover>());
+      ConfigureManipulators(operators.OfType<IBinaryVectorManipulator>());
+      ConfigureMoveOperators(operators.OfType<IBinaryVectorMoveOperator>());
+      ConfigureShakingOperators(operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>());
+    }
+
+    #region Specific Operator Wiring
+    private void ConfigureCreators(IEnumerable<IBinaryVectorCreator> creators) {
+      foreach (var creator in creators) {
+        creator.BinaryVectorParameter.ActualName = Name;
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+      }
+    }
+    private void ConfigureCrossovers(IEnumerable<IBinaryVectorCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ParentsParameter.ActualName = Name;
+        crossover.ChildParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureManipulators(IEnumerable<IBinaryVectorManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.BinaryVectorParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureMoveOperators(IEnumerable<IBinaryVectorMoveOperator> moveOperators) {
+      foreach (var moveOperator in moveOperators) {
+        moveOperator.BinaryVectorParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureShakingOperators(IEnumerable<IBinaryVectorMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.BinaryVectorParameter.ActualName = Name;
+      }
+    }
+    #endregion
   }
 }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs

@@ -25 +25 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -35 +36 @@
     }
 
-    [StorableConstructor]
-    protected Encoding(bool deserializing) : base(deserializing) { }
-    protected Encoding(Encoding original, Cloner cloner)
-      : base(original, cloner) { }
-    protected Encoding(string name) : base(name) { }
-
     public virtual IEnumerable<IValueParameter> Parameters {
       get { return Enumerable.Empty<IValueParameter>(); }
@@ -50 +45 @@
     }
 
+    public virtual ISolutionCreator DefaultSolutionCreator {
+      get { return null; }
+    }
+
+    [StorableConstructor]
+    protected Encoding(bool deserializing) : base(deserializing) { }
+    protected Encoding(Encoding original, Cloner cloner)
+      : base(original, cloner) { }
+    protected Encoding(string name) : base(name) { }
+
     public event EventHandler ParameterConfigurationChanged;
     protected virtual void OnParameterConfigurationChanged() {

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs

@@ -76 +76 @@
     }
 
-    public IRealVectorCreator DefaultSolutionCreator {
+    public override ISolutionCreator DefaultSolutionCreator {
       get { return Operators.OfType<UniformRandomRealVectorCreator>().First(); }
     }
@@ -166 +166 @@
     static RealEncoding() {
       encodingSpecificOperatorTypes = new List<Type>() {
+        typeof (IRealVectorOperator),
         typeof (IRealVectorCreator),
         typeof (IRealVectorCrossover),