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

Timestamp:

11/13/14 16:46:40 (10 years ago)

Author:

mkommend

Message:

#2174: Updated IEncoding interface, adapted problems and refactored operator discovery in realencoding

Location:

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

Files:

• Encoding.cs (modified) (1 diff)
• RealEncoding.cs (modified) (10 diffs)

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

@@ -41 +41 @@
     protected Encoding(string name) : base(name) { }
 
-    public virtual IEnumerable<IValueParameter> EncodingParameters {
+    public virtual IEnumerable<IValueParameter> Parameters {
       get { return Enumerable.Empty<IValueParameter>(); }
+    }
+
+    public virtual IEnumerable<IOperator> Operators {
+      get { return Enumerable.Empty<IOperator>(); }
+      protected set { }
     }
 

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

@@ -24 +24 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
 using HeuristicLab.Common;
@@ -38 +39 @@
   [StorableClass]
   public sealed class RealEncoding : Encoding {
-
+    #region Encoding Parameters
     [Storable]
     private IFixedValueParameter<IntValue> lengthParameter;
@@ -63 +64 @@
     }
 
-    public override IEnumerable<IValueParameter> EncodingParameters {
-      get { return base.EncodingParameters.Concat(new IValueParameter[] { LengthParameter, BoundsParameter }); }
+    public override IEnumerable<IValueParameter> Parameters {
+      get { return base.Parameters.Concat(new IValueParameter[] { LengthParameter, BoundsParameter }); }
+    }
+    #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 IRealVectorCreator DefaultSolutionCreator {
+      get { return Operators.OfType<UniformRandomRealVectorCreator>().First(); }
     }
 
@@ -76 +89 @@
     }
 
-    public IRealVectorCreator DefaultSolutionCreator {
-      get {
-        var creator = new UniformRandomRealVectorCreator();
-        creator.RealVectorParameter.ActualName = Name;
-        creator.LengthParameter.ActualName = LengthParameter.Name;
-        creator.BoundsParameter.ActualName = BoundsParameter.Name;
-        return creator;
-      }
-    }
+
 
     [StorableConstructor]
@@ -91 +96 @@
     private void AfterDeserialization() {
       RegisterParameterEvents();
+      DiscoverOperators();
     }
 
@@ -98 +104 @@
       lengthParameter = cloner.Clone(original.lengthParameter);
       boundsParameter = cloner.Clone(original.boundsParameter);
+      encodingOperators = original.Operators.Select(cloner.Clone).ToList();
       RegisterParameterEvents();
     }
+
+
 
     public RealEncoding(string name, int length, double min, double max)
@@ -112 +121 @@
       boundsParameter = new ValueParameter<DoubleMatrix>(Name + "Bounds", bounds);
       RegisterParameterEvents();
+      DiscoverOperators();
     }
 
@@ -128 +138 @@
       boundsParameter = new ValueParameter<DoubleMatrix>(Name + "Bounds", bounds);
       RegisterParameterEvents();
+      DiscoverOperators();
     }
 
     private void OnLengthParameterChanged() {
       RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
     }
     private void OnBoundsParameterChanged() {
       RegisterBoundsParameterEvents();
-    }
-    private void RegisterParameterEvents()
-    {
+      ConfigureOperators(Operators);
+    }
+    private void RegisterParameterEvents() {
       RegisterLengthParameterEvents();
       RegisterBoundsParameterEvents();
     }
     private void RegisterLengthParameterEvents() {
-      //TODO fire correct event
-      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
-      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
+      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
     }
     private void RegisterBoundsParameterEvents() {
-      //TODO fire correct event
-      BoundsParameter.ValueChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
-      boundsParameter.Value.ToStringChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
-    }
-
-    public void DiscoverOperators() {
-      var types = new List<Type>()
-      {
+      BoundsParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      boundsParameter.Value.ToStringChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static RealEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
         typeof (IRealVectorCreator),
         typeof (IRealVectorCrossover),
         typeof (IRealVectorManipulator),
         typeof (IRealVectorStdDevStrategyParameterOperator),
+        typeof (IRealVectorSwarmUpdater),
         typeof (IRealVectorParticleCreator),
         typeof (IRealVectorParticleUpdater),
-        typeof (IRealVectorParticleUpdater),
+        typeof (IRealVectorMultiNeighborhoodShakingOperator),
+        typeof (IRealVectorBoundsChecker),
+        typeof (IRealVectorMoveOperator),
+        typeof (IRealVectorMoveGenerator)
       };
-      var discoveredTypes = ApplicationManager.Manager.GetTypes(types, true, false, false);
-      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t)).ToList();
-    }
+    }
+    private void DiscoverOperators() {
+      var pluginDescription = ApplicationManager.Manager.GetDeclaringPlugin(typeof(IRealVectorOperator));
+      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) {
@@ -176 +199 @@
       ConfigureParticleUpdaters(operators.OfType<IRealVectorParticleUpdater>());
       ConfigureShakingOperators(operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>());
-    }
-
+      ConfigureBoundsCheckers(operators.OfType<IRealVectorBoundsChecker>());
+      ConfigureMoveOperators(operators.OfType<IRealVectorMoveOperator>());
+      ConfigureMoveGenerators(operators.OfType<IRealVectorMoveGenerator>());
+    }
+
+    #region Specific Operator Wiring
     private void ConfigureCreators(IEnumerable<IRealVectorCreator> creators) {
       foreach (var creator in creators) {
@@ -260 +287 @@
       }
     }
+    private void ConfigureBoundsCheckers(IEnumerable<IRealVectorBoundsChecker> boundsCheckers) {
+      foreach (var boundsChecker in boundsCheckers) {
+        boundsChecker.RealVectorParameter.ActualName = Name;
+        boundsChecker.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureMoveOperators(IEnumerable<IRealVectorMoveOperator> moveOperators) {
+      foreach (var moveOperator in moveOperators)
+        moveOperator.RealVectorParameter.ActualName = Name;
+    }
+
+    private void ConfigureMoveGenerators(IEnumerable<IRealVectorMoveGenerator> moveGenerators) {
+      foreach (var moveGenerator in moveGenerators)
+        moveGenerator.BoundsParameter.ActualName = BoundsParameter.Name;
+    }
+    #endregion
   }
 }