Changeset 11546 for branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs

Timestamp:

11/12/14 23:48:56 (9 years ago)

Author:

mkommend

Message:

#2174: Extracted wiring of real vector operators from the single objective programmable problem to the real encoding.

File:

• branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs (modified) (7 diffs)

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

@@ -21 +21 @@
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -31 +32 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.Programmable {
@@ -42 +44 @@
       get { return lengthParameter; }
       set {
-        if(value == null) throw new ArgumentNullException("Length parameter must not be null.");
+        if (value == null) throw new ArgumentNullException("Length parameter must not be null.");
         if (lengthParameter == value) return;
         lengthParameter = value;
@@ -74 +76 @@
     }
 
-    public ISolutionCreator SolutionCreator {
+    public IRealVectorCreator DefaultSolutionCreator {
       get {
         var creator = new UniformRandomRealVectorCreator();
@@ -83 +85 @@
       }
     }
-      
+
     [StorableConstructor]
     private RealEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new RealEncoding(this, cloner); }
     private RealEncoding(RealEncoding original, Cloner cloner)
       : base(original, cloner) {
       lengthParameter = cloner.Clone(original.lengthParameter);
       boundsParameter = cloner.Clone(original.boundsParameter);
-    }
+      RegisterParameterEvents();
+    }
+
     public RealEncoding(string name, int length, double min, double max)
       : base(name) {
@@ -101 +111 @@
       lengthParameter = new FixedValueParameter<IntValue>(Name + "Length", new IntValue(length));
       boundsParameter = new ValueParameter<DoubleMatrix>(Name + "Bounds", bounds);
-    }
+      RegisterParameterEvents();
+    }
+
     public RealEncoding(string name, int length, IList<double> min, IList<double> max)
       : base(name) {
@@ -115 +127 @@
       lengthParameter = new FixedValueParameter<IntValue>(Name + "Length", new IntValue(length));
       boundsParameter = new ValueParameter<DoubleMatrix>(Name + "Bounds", bounds);
-    }  
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RealEncoding(this, cloner);
+      RegisterParameterEvents();
     }
 
     private void OnLengthParameterChanged() {
-       //TODO rewire parameters
-    }
-
+      RegisterLengthParameterEvents();
+    }
     private void OnBoundsParameterChanged() {
-      //TODO rewire parameters      
-    }
-
-
+      RegisterBoundsParameterEvents();
+    }
+    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>());
+    }
+    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>()
+      {
+        typeof (IRealVectorCreator),
+        typeof (IRealVectorCrossover),
+        typeof (IRealVectorManipulator),
+        typeof (IRealVectorStdDevStrategyParameterOperator),
+        typeof (IRealVectorParticleCreator),
+        typeof (IRealVectorParticleUpdater),
+        typeof (IRealVectorParticleUpdater),
+      };
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(types, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t)).ToList();
+    }
+
+    public void ConfigureOperators(IEnumerable<IOperator> operators) {
+      ConfigureCreators(operators.OfType<IRealVectorCreator>());
+      ConfigureCrossovers(operators.OfType<IRealVectorCrossover>());
+      ConfigureManipulators(operators.OfType<IRealVectorManipulator>());
+      ConfigureStdDevStrategyParameterOperators(operators.OfType<IRealVectorStdDevStrategyParameterOperator>());
+      ConfigureSwarmUpdaters(operators.OfType<IRealVectorSwarmUpdater>());
+      ConfigureParticleCreators(operators.OfType<IRealVectorParticleCreator>());
+      ConfigureParticleUpdaters(operators.OfType<IRealVectorParticleUpdater>());
+      ConfigureShakingOperators(operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>());
+    }
+
+    private void ConfigureCreators(IEnumerable<IRealVectorCreator> creators) {
+      foreach (var creator in creators) {
+        creator.RealVectorParameter.ActualName = Name;
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+        creator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureCrossovers(IEnumerable<IRealVectorCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+        crossover.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureManipulators(IEnumerable<IRealVectorManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.RealVectorParameter.ActualName = Name;
+        manipulator.BoundsParameter.ActualName = BoundsParameter.Name;
+        manipulator.BoundsParameter.Hidden = true;
+        var sm = manipulator as ISelfAdaptiveManipulator;
+        if (sm != null) {
+          var p = sm.StrategyParameterParameter as ILookupParameter;
+          if (p != null) {
+            p.ActualName = Name + "Strategy";
+            p.Hidden = true;
+          }
+        }
+      }
+    }
+    private void ConfigureStdDevStrategyParameterOperators(IEnumerable<IRealVectorStdDevStrategyParameterOperator> strategyOperators) {
+      var bounds = (DoubleMatrix)Bounds.Clone();
+      for (var i = 0; i < bounds.Rows; i++) {
+        bounds[i, 1] = 0.1 * (bounds[i, 1] - bounds[i, 0]);
+        bounds[i, 0] = 0;
+      }
+      foreach (var s in strategyOperators) {
+        var c = s as IRealVectorStdDevStrategyParameterCreator;
+        if (c != null) {
+          c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          c.LengthParameter.ActualName = LengthParameter.Name;
+          c.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+        var m = s as IRealVectorStdDevStrategyParameterManipulator;
+        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 IRealVectorStdDevStrategyParameterCrossover;
+        if (x != null) {
+          x.ParentsParameter.ActualName = Name + "Strategy";
+          x.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+      }
+    }
+    private void ConfigureSwarmUpdaters(IEnumerable<IRealVectorSwarmUpdater> swarmUpdaters) {
+      foreach (var su in swarmUpdaters) {
+        su.RealVectorParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureParticleCreators(IEnumerable<IRealVectorParticleCreator> particleCreators) {
+      foreach (var particleCreator in particleCreators) {
+        particleCreator.RealVectorParameter.ActualName = Name;
+        particleCreator.BoundsParameter.ActualName = BoundsParameter.Name;
+        particleCreator.ProblemSizeParameter.ActualName = LengthParameter.Name;
+      }
+    }
+    private void ConfigureParticleUpdaters(IEnumerable<IRealVectorParticleUpdater> particleUpdaters) {
+      foreach (var particleUpdater in particleUpdaters) {
+        particleUpdater.RealVectorParameter.ActualName = Name;
+        particleUpdater.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureShakingOperators(IEnumerable<IRealVectorMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.RealVectorParameter.ActualName = Name;
+      }
+    }
   }
-}                            
+}