Changeset 11575 for branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.cs

Timestamp:

11/24/14 17:08:24 (9 years ago)

Author:

mkommend

Message:

#2174: Adapted permutation encoding.

File:

• branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.cs (modified) (1 diff)

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.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.PermutationEncoding;
+using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.Programmable {
   [Item("PermutationEncoding", "Describes a permutation encoding.")]
   [StorableClass]
-  public class PermutationEncoding : Encoding<IPermutationCreator> {
+  public sealed class PermutationEncoding : Encoding<IPermutationCreator> {
+    #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();
       }
     }
 
     [Storable]
-    private PermutationType type;
-    public PermutationType Type {
-      get { return type; }
+    private IFixedValueParameter<PermutationType> permutationTypeParameter;
+    public IFixedValueParameter<PermutationType> PermutationTypeParameter {
+      get { return permutationTypeParameter; }
       set {
-        if (type == value) return;
-        type = value;
-        OnParameterConfigurationChanged();
-      }
+        if (value == null) throw new ArgumentNullException("Permutation type parameter must not be null.");
+        if (permutationTypeParameter == value) return;
+        permutationTypeParameter = value;
+        OnPermutationTypeParameterChanged();
+      }
+    }
+
+    public override IEnumerable<IValueParameter> Parameters {
+      get { return base.Parameters.Concat(new IValueParameter[] { LengthParameter, PermutationTypeParameter }); }
+    }
+    #endregion
+
+    public int Length {
+      get { return LengthParameter.Value.Value; }
+      set { LengthParameter.Value.Value = value; }
+    }
+
+    public PermutationTypes Type {
+      get { return PermutationTypeParameter.Value.Value; }
+      set { PermutationTypeParameter.Value.Value = value; }
     }
 
     [StorableConstructor]
-    protected PermutationEncoding(bool deserializing) : base(deserializing) { }
-    protected PermutationEncoding(PermutationEncoding original, Cloner cloner)
+    private PermutationEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new PermutationEncoding(this, cloner); }
+    private PermutationEncoding(PermutationEncoding original, Cloner cloner)
       : base(original, cloner) {
-      length = cloner.Clone(original.length);
-      type = cloner.Clone(original.type);
+      lengthParameter = cloner.Clone(original.lengthParameter);
+      permutationTypeParameter = cloner.Clone(original.permutationTypeParameter);
+      RegisterParameterEvents();
     }
     public PermutationEncoding(string name, int length, PermutationTypes type)
       : base(name) {
-      this.length = new IntValue(length);
-      this.type = new PermutationType(type);
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PermutationEncoding(this, cloner);
-    }
-
+      Length = length;
+      Type = type;
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private void OnLengthParameterChanged() {
+      RegisterParameterEvents();
+      ConfigureOperators(Operators);
+    }
+
+    private void OnPermutationTypeParameterChanged() {
+      RegisterParameterEvents();
+      ConfigureOperators(Operators);
+    }
+
+    private void RegisterParameterEvents() {
+      RegisterLengthParameterEvents();
+      RegisterPermutationTypeParameterEvents();
+    }
+    private void RegisterLengthParameterEvents() {
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+    private void RegisterPermutationTypeParameterEvents() {
+      PermutationTypeParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static PermutationEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+          typeof (IPermutationOperator),
+          typeof (IPermutationCreator),
+          typeof (IPermutationCrossover),
+          typeof (IPermutationManipulator),
+          typeof (IPermutationMultiNeighborhoodShakingOperator),
+          typeof (IPermutationMoveOperator),
+          typeof (IPermutationInversionMoveOperator),
+          typeof (IPermutationScrambleMoveOperator),
+          typeof (IPermutationSwap2MoveOperator),                    
+          typeof (IPermutationTranslocationMoveOperator)
+      };
+    }
+    private void DiscoverOperators() {
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, 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 override void ConfigureOperators(IEnumerable<IOperator> operators) {
+      base.ConfigureOperators(operators);
+      ConfigureCreators(Operators.OfType<IPermutationCreator>());
+      ConfigureCrossovers(Operators.OfType<IPermutationCrossover>());
+      ConfigureManipulators(Operators.OfType<IPermutationManipulator>());
+      ConfigureShakingOperators(Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>());
+      ConfigureMoveOperators(Operators.OfType<IPermutationMoveOperator>());
+      ConfigureInversionMoveOperators(Operators.OfType<IPermutationInversionMoveOperator>());
+      ConfigureScrambleMoveOperators(Operators.OfType<IPermutationScrambleMoveOperator>());
+      ConfigureSwap2MoveOperators(Operators.OfType<IPermutationSwap2MoveOperator>());
+      ConfigureTranslocationMoveOperators(Operators.OfType<IPermutationTranslocationMoveOperator>());
+    }
+
+    #region specific operator wiring
+    private void ConfigureCreators(IEnumerable<IPermutationCreator> creators) {
+      foreach (var creator in creators) {
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+        creator.PermutationParameter.ActualName = Name;
+        creator.PermutationTypeParameter.Value.Value = Type;
+      }
+    }
+    private void ConfigureCrossovers(IEnumerable<IPermutationCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureManipulators(IEnumerable<IPermutationManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.PermutationParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureShakingOperators(IEnumerable<IPermutationMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.PermutationParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureMoveOperators(IEnumerable<IPermutationMoveOperator> moveOperators) {
+      foreach (var moveOperator in moveOperators) {
+        moveOperator.PermutationParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureInversionMoveOperators(IEnumerable<IPermutationInversionMoveOperator> inversionMoveOperators) {
+      foreach (var inversionMoveOperator in inversionMoveOperators) {
+        inversionMoveOperator.InversionMoveParameter.ActualName = Name + "_InversionMove";
+      }
+    }
+    private void ConfigureScrambleMoveOperators(IEnumerable<IPermutationScrambleMoveOperator> scrambleMoveOperators) {
+      foreach (var scrambleMoveOperator in scrambleMoveOperators) {
+        scrambleMoveOperator.ScrambleMoveParameter.ActualName = Name + "_ScambleMove";
+      }
+    }
+    private void ConfigureSwap2MoveOperators(IEnumerable<IPermutationSwap2MoveOperator> swap2MoveOperators) {
+      foreach (var swap2MoveOperator in swap2MoveOperators) {
+        swap2MoveOperator.Swap2MoveParameter.ActualName = Name + "_Swap2Move";
+      }
+    }
+    private void ConfigureTranslocationMoveOperators(IEnumerable<IPermutationTranslocationMoveOperator> translocationMoveOperators) {
+      foreach (var translocationMoveOperator in translocationMoveOperators) {
+        translocationMoveOperator.TranslocationMoveParameter.ActualName = Name + "_TranslocationMove";
+      }
+    }
+
+    #endregion
   }
 }