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

Timestamp:

11/20/14 17:20:29 (10 years ago)

Author:

mkommend

Message:

#2174: Adapted IntegerEncoding to include the wiring code of operators.

Location:

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

Files:

• IntegerEncoding.cs (modified) (3 diffs)
• RealEncoding.cs (modified) (2 diffs)

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

@@ -27 +27 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.Programmable {
@@ -33 +35 @@
   [StorableClass]
   public class IntegerEncoding : Encoding<IIntegerVectorCreator> {
+    #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 IntMatrix bounds;
+    private IValueParameter<IntMatrix> boundsParameter;
+    public IValueParameter<IntMatrix> BoundsParameter {
+      get { return boundsParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Bounds parameter must not be null.");
+        if (boundsParameter == value) return;
+        boundsParameter = value;
+        OnBoundsParameterChanged();
+      }
+    }
+
+    public override IEnumerable<IValueParameter> Parameters {
+      get { return base.Parameters.Concat(new IValueParameter[] { LengthParameter, BoundsParameter }); }
+    }
+    #endregion
+
+    public int Length {
+      get { return LengthParameter.Value.Value; }
+      set { LengthParameter.Value.Value = value; }
+    }
     public IntMatrix Bounds {
-      get { return bounds; }
-      set {
-        if (bounds == value) return;
-        bounds = value;
-        OnParameterConfigurationChanged();
-      }
+      get { return BoundsParameter.Value; }
+      set { BoundsParameter.Value = value; }
     }
 
     [StorableConstructor]
     protected IntegerEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
     protected IntegerEncoding(IntegerEncoding original, Cloner cloner)
       : base(original, cloner) {
-      length = cloner.Clone(original.length);
-      bounds = cloner.Clone(original.bounds);
-    }
+      lengthParameter = cloner.Clone(original.lengthParameter);
+      boundsParameter = cloner.Clone(original.boundsParameter);
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new IntegerEncoding(this, cloner); }
+
     public IntegerEncoding(string name, int length, int min, int max, int? step = null)
       : base(name) {
       if (min >= max) throw new ArgumentException("min must be less than max", "min");
       if (step.HasValue && step.Value <= 0) throw new ArgumentException("step must be greater than zero or null", "step");
-      this.length = new IntValue(length);
-      bounds = new IntMatrix(1, step.HasValue ? 3 : 2);
-      bounds[0, 0] = min;
-      bounds[0, 1] = max;
-      if (step.HasValue) bounds[0, 2] = step.Value;
+      Length = length;
+      Bounds = new IntMatrix(1, step.HasValue ? 3 : 2);
+      Bounds[0, 0] = min;
+      Bounds[0, 1] = max;
+      if (step.HasValue) Bounds[0, 2] = step.Value;
+      RegisterParameterEvents();
+      DiscoverOperators();
     }
     public IntegerEncoding(string name, int length, IList<int> min, IList<int> max, IList<int> step = null)
@@ -78 +109 @@
       if (step != null && min.Count != step.Count) throw new ArgumentException("step must be of the same length as min or null", "step");
       if (min.Zip(max, (mi, ma) => mi >= ma).Any(x => x)) throw new ArgumentException("min must be less than max in each dimension", "min");
-      this.length = new IntValue(length);
-      bounds = new IntMatrix(min.Count, step != null ? 3 : 2);
+      Length = length;
+      Bounds = new IntMatrix(min.Count, step != null ? 3 : 2);
       for (int i = 0; i < min.Count; i++) {
-        bounds[i, 0] = min[i];
-        bounds[i, 1] = max[i];
-        if (step != null) bounds[i, 2] = step[i];
-      }
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new IntegerEncoding(this, cloner);
-    }
-
+        Bounds[i, 0] = min[i];
+        Bounds[i, 1] = max[i];
+        if (step != null) Bounds[i, 2] = step[i];
+      }
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private void OnLengthParameterChanged() {
+      RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnBoundsParameterChanged() {
+      RegisterBoundsParameterEvents();
+      ConfigureOperators(Operators);
+    }
+
+    private void RegisterParameterEvents() {
+      RegisterLengthParameterEvents();
+      RegisterBoundsParameterEvents();
+    }
+    private void RegisterLengthParameterEvents() {
+      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+    private void RegisterBoundsParameterEvents() {
+      BoundsParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      boundsParameter.Value.ToStringChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static IntegerEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+        typeof (IIntegerVectorOperator),
+        typeof (IIntegerVectorCreator),
+        typeof (IIntegerVectorCrossover),
+        typeof (IIntegerVectorManipulator),
+        typeof (IIntegerVectorStdDevStrategyParameterOperator),
+        typeof (IIntegerVectorMultiNeighborhoodShakingOperator),
+      };
+    }
+    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) {
+      ConfigureBoundedOperators(Operators.OfType<IBoundedIntegerVectorOperator>());
+      ConfigureCreators(Operators.OfType<IIntegerVectorCreator>());
+      ConfigureCrossovers(Operators.OfType<IIntegerVectorCrossover>());
+      ConfigureManipulators(Operators.OfType<IIntegerVectorManipulator>());
+      ConfigureShakingOperators(Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>());
+      ConfigureStrategyVectorOperator(Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>());
+    }
+
+    #region Specific Operator Wiring
+    private void ConfigureBoundedOperators(IEnumerable<IBoundedIntegerVectorOperator> boundedOperators) {
+      foreach (var boundedOperator in boundedOperators) {
+        boundedOperator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+
+    private void ConfigureCreators(IEnumerable<IIntegerVectorCreator> creators) {
+      foreach (var creator in creators) {
+        creator.IntegerVectorParameter.ActualName = Name;
+        creator.BoundsParameter.ActualName = BoundsParameter.Name;
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+      }
+    }
+
+    private void ConfigureCrossovers(IEnumerable<IIntegerVectorCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+      }
+    }
+
+    private void ConfigureManipulators(IEnumerable<IIntegerVectorManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.IntegerVectorParameter.ActualName = Name;
+        manipulator.IntegerVectorParameter.Hidden = true;
+        var sm = manipulator as ISelfAdaptiveManipulator;
+        if (sm != null) {
+          var p = sm.StrategyParameterParameter as ILookupParameter;
+          if (p != null) {
+            p.ActualName = Name + "Strategy";
+          }
+        }
+      }
+    }
+
+    private void ConfigureShakingOperators(IEnumerable<IIntegerVectorMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.IntegerVectorParameter.ActualName = Name;
+      }
+    }
+
+    private void ConfigureStrategyVectorOperator(IEnumerable<IIntegerVectorStdDevStrategyParameterOperator> strategyVectorOperators) {
+      var bounds = new DoubleMatrix(Bounds.Rows, Bounds.Columns);
+      for (var i = 0; i < bounds.Rows; i++) {
+        bounds[i, 1] = (int)Math.Ceiling(0.33 * (Bounds[i, 1] - Bounds[i, 0]));
+        bounds[i, 0] = 0;
+        if (bounds.Columns > 2) bounds[i, 2] = Bounds[i, 2];
+      }
+      foreach (var s in strategyVectorOperators) {
+        var c = s as IIntegerVectorStdDevStrategyParameterCreator;
+        if (c != null) {
+          c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          c.LengthParameter.ActualName = Name;
+          c.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+        var m = s as IIntegerVectorStdDevStrategyParameterManipulator;
+        if (m != null) {
+          m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          m.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+        var mm = s as StdDevStrategyVectorManipulator;
+        if (mm != null) {
+          mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Length));
+          mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(Length)));
+        }
+        var x = s as IIntegerVectorStdDevStrategyParameterCrossover;
+        if (x != null) {
+          x.ParentsParameter.ActualName = Name + "Strategy";
+          x.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+      }
+    }
+    #endregion
   }
 }

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

@@ -148 +148 @@
     static RealEncoding() {
       encodingSpecificOperatorTypes = new List<Type>() {
-  typeof (IRealVectorOperator),
-  typeof (IRealVectorCreator),
-  typeof (IRealVectorCrossover),
-  typeof (IRealVectorManipulator),
-  typeof (IRealVectorStdDevStrategyParameterOperator),
-  typeof (IRealVectorSwarmUpdater),
-  typeof (IRealVectorParticleCreator),
-  typeof (IRealVectorParticleUpdater),
-  typeof (IRealVectorMultiNeighborhoodShakingOperator),
-  typeof (IRealVectorBoundsChecker),
-  typeof (IRealVectorMoveOperator),
-  typeof (IRealVectorMoveGenerator)
-  };
+          typeof (IRealVectorOperator),
+          typeof (IRealVectorCreator),
+          typeof (IRealVectorCrossover),
+          typeof (IRealVectorManipulator),
+          typeof (IRealVectorStdDevStrategyParameterOperator),
+          typeof (IRealVectorSwarmUpdater),
+          typeof (IRealVectorParticleCreator),
+          typeof (IRealVectorParticleUpdater),
+          typeof (IRealVectorMultiNeighborhoodShakingOperator),
+          typeof (IRealVectorBoundsChecker),
+          typeof (IRealVectorMoveOperator),
+          typeof (IRealVectorMoveGenerator)
+      };
     }
     private void DiscoverOperators() {
@@ -223 +223 @@
           if (p != null) {
             p.ActualName = Name + "Strategy";
-            p.Hidden = true;
           }
         }