Changeset 11575

Timestamp:

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

Author:

mkommend

Message:

#2174: Adapted permutation encoding.

Location:

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3

Files:

• Encodings/BinaryEncoding.cs (modified) (2 diffs)
• Encodings/PermutationEncoding.cs (modified) (1 diff)
• MultiObjectiveProgrammableProblem.cs (modified) (2 diffs)
• SingleObjectiveProgrammableProblem.cs (modified) (3 diffs)

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

@@ -116 +116 @@
       ConfigureManipulators(operators.OfType<IBinaryVectorManipulator>());
       ConfigureMoveOperators(operators.OfType<IBinaryVectorMoveOperator>());
+      ConfigureBitFlipMoveOperators(operators.OfType<IOneBitflipMoveOperator>());
       ConfigureShakingOperators(operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>());
     }
@@ -142 +143 @@
       }
     }
+    private void ConfigureBitFlipMoveOperators(IEnumerable<IOneBitflipMoveOperator> oneBitflipMoveOperators) {
+      foreach (var oneBitFlipMoveOperator in oneBitflipMoveOperators) {
+        oneBitFlipMoveOperator.OneBitflipMoveParameter.ActualName = Name + "_OneBitFlipMove";
+      }
+    }
     private void ConfigureShakingOperators(IEnumerable<IBinaryVectorMultiNeighborhoodShakingOperator> shakingOperators) {
       foreach (var shakingOperator in shakingOperators) {

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
   }
 }

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

@@ -211 +211 @@
       var permEnc = encoding as PermutationEncoding;
       if (permEnc != null) {
-        var l = new ValueParameter<IntValue>(permEnc.Name + "Length", permEnc.Length);
+        var l = new ValueParameter<IntValue>(permEnc.Name + "Length", new IntValue(permEnc.Length));
         DynamicEncodingParameters.Add(l);
 
@@ -217 +217 @@
         creator.PermutationParameter.ActualName = permEnc.Name;
         creator.LengthParameter.ActualName = l.Name;
-        creator.PermutationTypeParameter.Value = permEnc.Type;
+        creator.PermutationTypeParameter.Value = new PermutationType(permEnc.Type);
         return creator;
       }

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

@@ -205 +205 @@
       if (intEnc != null) {
         DynamicEncodingParameters.AddRange(intEnc.Parameters);
-        return intEnc.DefaultSolutionCreator;
+        return intEnc.SolutionCreator;
+      }
+      #endregion
+      #region Configure Permutation Creator
+      var permEnc = encoding as PermutationEncoding;
+      if (permEnc != null) {
+        DynamicEncodingParameters.AddRange(permEnc.Parameters);
+        return permEnc.SolutionCreator;
       }
       #endregion
@@ -219 +226 @@
       }
       #endregion
-      #region Configure Permutation Creator
-      var permEnc = encoding as PermutationEncoding;
-      if (permEnc != null) {
-        var l = new ValueParameter<IntValue>(permEnc.Name + "Length", permEnc.Length);
-        DynamicEncodingParameters.Add(l);
-
-        var creator = new RandomPermutationCreator();
-        creator.PermutationParameter.ActualName = permEnc.Name;
-        creator.LengthParameter.ActualName = l.Name;
-        creator.PermutationTypeParameter.Value = permEnc.Type;
-        return creator;
-      }
-      #endregion
       throw new ArgumentException(string.Format("Encoding {0} is unknown.", encoding != null ? encoding.GetType().FullName : "(null)"));
     }
 
-
-    private IEnumerable<IOperator> GetDiscoveredOperators<T>() where T : class,IOperator {
-      return ApplicationManager.Manager.GetInstances<T>()
-          .Except(Operators.OfType<T>(), new TypeEqualityComparer<T>());
-    }
     protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, IEncoding encoding) {
       // remove all multiencoding operators
@@ -283 +272 @@
       #endregion
       #region Configure Operators for PermutationEncoding
-      var permCreator = newCreator as IPermutationCreator;
-      if (permCreator != null) {
-        var paramName = permCreator.PermutationParameter.ActualName;
+      var permEncoding = encoding as PermutationEncoding;
+      if (permEncoding != null) {
         // do not replace a permutation creator that was manually set
         if (!(SolutionCreator is IPermutationCreator)
-            || ((IPermutationCreator)SolutionCreator).PermutationParameter.ActualName != permCreator.PermutationParameter.ActualName) {
+            || ((IPermutationCreator)SolutionCreator).PermutationParameter.ActualName != permEncoding.Name) {
           Operators.Remove(SolutionCreator);
           SolutionCreator = newCreator;
-          Operators.Add(SolutionCreator);
-        }
-
-        #region Wire Permutation Crossovers
-        var crossovers = Operators.OfType<IPermutationCrossover>()
-          .Union(ApplicationManager.Manager.GetInstances<IPermutationCrossover>(), new TypeEqualityComparer<IPermutationCrossover>())
-          .ToList();
-        foreach (var xo in crossovers) {
-          xo.ChildParameter.ActualName = permCreator.PermutationParameter.ActualName;
-          xo.ChildParameter.Hidden = true;
-          xo.ParentsParameter.ActualName = permCreator.PermutationParameter.ActualName;
-          xo.ParentsParameter.Hidden = true;
-        }
-        Operators.AddRange(crossovers.Except(Operators.OfType<IPermutationCrossover>()));
-        #endregion
-        #region Wire Permutation Manipulators
-        var manipulators = Operators.OfType<IPermutationManipulator>()
-          .Union(ApplicationManager.Manager.GetInstances<IPermutationManipulator>(), new TypeEqualityComparer<IPermutationManipulator>())
-          .ToList();
-        foreach (var m in manipulators) {
-          m.PermutationParameter.ActualName = permCreator.PermutationParameter.ActualName;
-          m.PermutationParameter.Hidden = true;
-        }
-        Operators.AddRange(manipulators.Except(Operators.OfType<IPermutationManipulator>()));
-        #endregion
-        #region Wire Permutation ShakingOperators
-        var shakingOperators = Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()
-          .Union(ApplicationManager.Manager.GetInstances<IPermutationMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IPermutationMultiNeighborhoodShakingOperator>())
-          .ToList();
-        foreach (var op in shakingOperators) {
-          op.PermutationParameter.ActualName = paramName;
-          op.PermutationParameter.Hidden = true;
-        }
-        Operators.AddRange(shakingOperators.Except(Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()));
-        #endregion
+        }
       } else {
         Operators.RemoveAll(x => x is IPermutationCrossover