Changeset 5410 for branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs

Timestamp:

02/03/11 12:23:40 (14 years ago)

Author:

mkofler

Message:

#852: Realized code cleanup as described in the reviewer comments by Andreas Beham.

File:

• branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs (modified) (9 diffs)

branches/PSO/HeuristicLab.Algorithms.ParticleSwarmOptimization/3.3/ParticleSwarmOptimization.cs

@@ -34 +34 @@
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Random;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Algorithms.ParticleSwarmOptimization {
@@ -65 +66 @@
 
     #region Parameter Properties
-    public ValueParameter<IntValue> SeedParameter {
-      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
-    }
-    public ValueParameter<BoolValue> SetSeedRandomlyParameter {
-      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
-    }
-    public ValueParameter<IntValue> SwarmSizeParameter {
-      get { return (ValueParameter<IntValue>)Parameters["SwarmSize"]; }
-    }
-    public ValueParameter<IntValue> MaxIterationsParameter {
-      get { return (ValueParameter<IntValue>)Parameters["MaxIterations"]; }
-    }
-    public ValueParameter<DoubleValue> OmegaParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["Omega"]; }
-    }
-    public ValueParameter<DoubleValue> Phi_PParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["Phi_P"]; }
-    }
-    public ValueParameter<DoubleValue> Phi_GParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["Phi_G"]; }
-    }
-    public ValueParameter<MultiAnalyzer> AnalyzerParameter {
-      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
-    }
-    public ValueLookupParameter<DoubleMatrix> VelocityBoundsParameter {
-      get { return (ValueLookupParameter<DoubleMatrix>)Parameters["VelocityBounds"]; }
+    public IValueParameter<IntValue> SeedParameter {
+      get { return (IValueParameter<IntValue>)Parameters["Seed"]; }
+    }
+    public IValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (IValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
+    }
+    public IValueParameter<IntValue> SwarmSizeParameter {
+      get { return (IValueParameter<IntValue>)Parameters["SwarmSize"]; }
+    }
+    public IValueParameter<IntValue> MaxIterationsParameter {
+      get { return (IValueParameter<IntValue>)Parameters["MaxIterations"]; }
+    }
+    public IValueParameter<DoubleValue> OmegaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Omega"]; }
+    }
+    public IValueParameter<DoubleValue> Phi_PParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Phi_P"]; }
+    }
+    public IValueParameter<DoubleValue> Phi_GParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Phi_G"]; }
+    }
+    public IValueParameter<MultiAnalyzer> AnalyzerParameter {
+      get { return (IValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
+    }
+    public IValueLookupParameter<DoubleMatrix> VelocityBoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["VelocityBounds"]; }
     }
     public ConstrainedValueParameter<IParticleUpdater> ParticleUpdaterParameter {
       get { return (ConstrainedValueParameter<IParticleUpdater>)Parameters["ParticleUpdater"]; }
     }
-    public ConstrainedValueParameter<ITopologyInitializer> TopologyInitializerParameter {
-      get { return (ConstrainedValueParameter<ITopologyInitializer>)Parameters["TopologyInitializer"]; }
-    }
-    public ConstrainedValueParameter<ITopologyUpdater> TopologyUpdaterParameter {
-      get { return (ConstrainedValueParameter<ITopologyUpdater>)Parameters["TopologyUpdater"]; }
+    public OptionalConstrainedValueParameter<ITopologyInitializer> TopologyInitializerParameter {
+      get { return (OptionalConstrainedValueParameter<ITopologyInitializer>)Parameters["TopologyInitializer"]; }
+    }
+    public OptionalConstrainedValueParameter<ITopologyUpdater> TopologyUpdaterParameter {
+      get { return (OptionalConstrainedValueParameter<ITopologyUpdater>)Parameters["TopologyUpdater"]; }
     }
     public OptionalConstrainedValueParameter<IDiscreteDoubleMatrixModifier> VelocityBoundsUpdaterParameter {
@@ -134 +135 @@
 
     [StorableConstructor]
-    protected ParticleSwarmOptimization(bool deserializing) : base(deserializing) {
-      Initialize();
+    protected ParticleSwarmOptimization(bool deserializing)
+      : base(deserializing) {
     }
     protected ParticleSwarmOptimization(ParticleSwarmOptimization original, Cloner cloner)
       : base(original, cloner) {
       qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      Initialize();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
       Initialize();
     }
@@ -154 +160 @@
       Parameters.Add(new ValueParameter<DoubleValue>("Phi_G", "Weight for global best position.", new DoubleValue(3.7)));
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("VelocityBounds", "Maximum Velocity in every dimension", new DoubleMatrix(new double[,] { { -1, 1 } })));
-      Parameters.Add(new ConstrainedValueParameter<IParticleUpdater>("ParticleUpdater", "Operator that calculates new position and velocity of a particle",
-        new ItemSet<IParticleUpdater>(ApplicationManager.Manager.GetInstances<IParticleUpdater>())));
-      Parameters.Add(new ConstrainedValueParameter<ITopologyInitializer>("TopologyInitializer", "Creates neighborhood description vectors",
-        new ItemSet<ITopologyInitializer>(ApplicationManager.Manager.GetInstances<ITopologyInitializer>())));
-      Parameters.Add(new ConstrainedValueParameter<ITopologyUpdater>("TopologyUpdater", "Updates the neighborhood description vectors",
-        new ItemSet<ITopologyUpdater>(ApplicationManager.Manager.GetInstances<ITopologyUpdater>())));
+      Parameters.Add(new ConstrainedValueParameter<IParticleUpdater>("ParticleUpdater", "Operator that calculates new position and velocity of a particle"));
+      Parameters.Add(new OptionalConstrainedValueParameter<ITopologyInitializer>("TopologyInitializer", "Creates neighborhood description vectors"));
+      Parameters.Add(new OptionalConstrainedValueParameter<ITopologyUpdater>("TopologyUpdater", "Updates the neighborhood description vectors"));
       Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("OmegaUpdater", "Updates the omega parameter"));
       Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleMatrixModifier>("VelocityBoundsUpdater", "Adjusts the velocity bounds."));
       ParticleUpdaterParameter.ActualValue = ParticleUpdaterParameter.ValidValues.SingleOrDefault(v => v.GetType() == typeof(TotallyConnectedParticleUpdater));
-      TopologyInitializerParameter.ActualValue = TopologyInitializerParameter.ValidValues.SingleOrDefault(v => v.GetType() == typeof(EmptyTopologyInitializer));
 
       RandomCreator randomCreator = new RandomCreator();
@@ -274 +276 @@
       UpdateOmegaUpdater();
       InitOmegaUpdater();
+      UpdateTopologyInitializer();
       Initialize();
-    }
-
-    private void Initialize() {
-      TopologyInitializerParameter.ValueChanged += new EventHandler(TopologyInitializerParameter_ValueChanged);
-      ParticleUpdaterParameter.ValueChanged += new EventHandler(ParticleUpdaterParameter_ValueChanged);
-      TopologyUpdaterParameter.ValueChanged += new EventHandler(TopologyUpdaterParameter_ValueChanged);
-    }
-
-    void TopologyUpdaterParameter_ValueChanged(object sender, EventArgs e) {
-      if (TopologyInitializer is EmptyTopologyInitializer) { // no topology updater allowed
-        if (TopologyUpdater != null) {
-          TopologyUpdater = null;
-        }
-      }
-    }
-
-    void ParticleUpdaterParameter_ValueChanged(object sender, EventArgs e) {
-      if (TopologyInitializer is EmptyTopologyInitializer) { // only global particle updater allowed
-        if (!(ParticleUpdater is IGlobalParticleUpdater)) {
-          ParticleUpdater = ParticleUpdaterParameter.ValidValues.Where(x => x is IGlobalParticleUpdater).First();
-        }
-      } else {  // only local particle updater allowed
-        if (!(ParticleUpdater is ILocalParticleUpdater)) {
-          ParticleUpdater = ParticleUpdaterParameter.ValidValues.Where(x => x is ILocalParticleUpdater).First();
-        }
-      }
-    }
-
-    void TopologyInitializerParameter_ValueChanged(object sender, EventArgs e) {
-      if (TopologyInitializer is EmptyTopologyInitializer) {   // only allow global particle update and no topology update
-        if (ParticleUpdaterParameter.ValidValues.Count > 0) {
-          if (!(ParticleUpdater is IGlobalParticleUpdater)) {
-            ParticleUpdater = ParticleUpdaterParameter.ValidValues.Where(x => x is IGlobalParticleUpdater).First();
-          }
-        }
-        if (TopologyUpdaterParameter.ValidValues.Count > 0) {
-          if (!(TopologyUpdater != null)) {
-            TopologyUpdater = null;
-          }
-        }
-      } else { // only allow local particle update; topology change possible
-        if (ParticleUpdaterParameter.ValidValues.Count > 0) {
-          if (!(ParticleUpdater is ILocalParticleUpdater)) {
-            ParticleUpdater = ParticleUpdaterParameter.ValidValues.Where(x => x is ILocalParticleUpdater).First();
-          }
-        }
-      }
-    }
-
-    private static void InitializeParticleCreator(CombinedOperator particleCreator) {
-      Placeholder positionCreator = new Placeholder();
-      Assigner personalBestPositionAssigner = new Assigner();
-      UniformRandomRealVectorCreator velocityCreator = new UniformRandomRealVectorCreator();
-
-      particleCreator.Name = "Particle Creator";
-      particleCreator.OperatorGraph.InitialOperator = positionCreator;
-
-      positionCreator.Name = "(SolutionCreator)";
-      positionCreator.OperatorParameter.ActualName = "SolutionCreator";
-      positionCreator.Successor = personalBestPositionAssigner;
-
-      personalBestPositionAssigner.LeftSideParameter.ActualName = "PersonalBestPoint";
-      personalBestPositionAssigner.RightSideParameter.ActualName = "Point";
-      personalBestPositionAssigner.Successor = velocityCreator;
-
-      velocityCreator.LengthParameter.ActualName = "ProblemSize";
-      velocityCreator.BoundsParameter.ActualName = "VelocityBounds";
-      velocityCreator.RealVectorParameter.ActualName = "Velocity";
     }
 
@@ -369 +304 @@
       UpdateAnalyzers();
       ParameterizeAnalyzers();
-      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
       base.OnProblemChanged();
     }
 
+    void TopologyInitializerParameter_ValueChanged(object sender, EventArgs e) {
+      this.UpdateTopologyParameters();
+    }
+
+    void VelocityBoundsUpdaterParameter_ValueChanged(object sender, EventArgs e) {
+      if (VelocityBoundsParameter.Value != null) {
+        foreach (IDiscreteDoubleMatrixModifier matrixOp in VelocityBoundsUpdaterParameter.Value.ScalingOperatorParameter.ValidValues) {
+          matrixOp.ValueParameter.ActualName = VelocityBoundsUpdater.ScaleParameter.Name;
+          matrixOp.StartValueParameter.Value = new DoubleValue(VelocityBoundsUpdater.ScaleParameter.ActualValue.Value);
+        }
+      }
+    }
     #endregion
 
     #region Helpers
-    private void InitializeParticleUpdaters() {
-    }
-
-    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+    private void Initialize() {
+      TopologyInitializerParameter.ValueChanged += new EventHandler(TopologyInitializerParameter_ValueChanged);
+    }
+
+    private static void InitializeParticleCreator(CombinedOperator particleCreator) {
+      Placeholder positionCreator = new Placeholder();
+      Assigner personalBestPositionAssigner = new Assigner();
+      UniformRandomRealVectorCreator velocityCreator = new UniformRandomRealVectorCreator();
+
+      particleCreator.Name = "Particle Creator";
+      particleCreator.OperatorGraph.InitialOperator = positionCreator;
+
+      positionCreator.Name = "(SolutionCreator)";
+      positionCreator.OperatorParameter.ActualName = "SolutionCreator";
+      positionCreator.Successor = personalBestPositionAssigner;
+
+      personalBestPositionAssigner.LeftSideParameter.ActualName = "PersonalBestPoint";
+      personalBestPositionAssigner.RightSideParameter.ActualName = "Point";
+      personalBestPositionAssigner.Successor = velocityCreator;
+
+      velocityCreator.LengthParameter.ActualName = "ProblemSize";
+      velocityCreator.BoundsParameter.ActualName = "VelocityBounds";
+      velocityCreator.RealVectorParameter.ActualName = "Velocity";
     }
 
@@ -385 +350 @@
       qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
       ParameterizeAnalyzers();
+    }
+
+    private void ParameterizeAnalyzers() {
+      if (Problem != null) {
+        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+      }
+    }
+
+    private void UpdateAnalyzers() {
+      Analyzer.Operators.Clear();
+      if (Problem != null) {
+        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>())
+          Analyzer.Operators.Add(analyzer);
+      }
+      Analyzer.Operators.Add(qualityAnalyzer);
     }
 
@@ -399 +381 @@
     }
 
-    void VelocityBoundsUpdaterParameter_ValueChanged(object sender, EventArgs e) {
-      if (VelocityBoundsParameter.Value != null) {
-        foreach (IDiscreteDoubleMatrixModifier matrixOp in VelocityBoundsUpdaterParameter.Value.ScalingOperatorParameter.ValidValues) {
-            matrixOp.ValueParameter.ActualName = VelocityBoundsUpdater.ScaleParameter.Name;
-            matrixOp.StartValueParameter.Value = new DoubleValue(VelocityBoundsUpdater.ScaleParameter.ActualValue.Value);
-        }
-      }
-    }
-
     private void InitOmegaUpdater() {
       foreach (IDiscreteDoubleValueModifier updater in OmegaUpdaterParameter.ValidValues) {
@@ -431 +404 @@
     }
 
-    private void ParameterizeAnalyzers() {
-      if (Problem != null) {
-        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
-        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
-        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
-      }
-    }
-
-    private void UpdateAnalyzers() {
-      Analyzer.Operators.Clear();
-      if (Problem != null) {
-        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>())
-          Analyzer.Operators.Add(analyzer);
-      }
-      Analyzer.Operators.Add(qualityAnalyzer);
-    }
-
+    private void UpdateTopologyInitializer() {
+      ITopologyInitializer oldTopologyInitializer = TopologyInitializer;
+      TopologyInitializerParameter.ValidValues.Clear();
+      foreach (ITopologyInitializer topologyInitializer in ApplicationManager.Manager.GetInstances<ITopologyInitializer>().OrderBy(x => x.Name)) {
+        TopologyInitializerParameter.ValidValues.Add(topologyInitializer);
+      }
+      if (oldTopologyInitializer != null && TopologyInitializerParameter.ValidValues.Any(x => x.GetType() == oldTopologyInitializer.GetType()))
+        TopologyInitializer = TopologyInitializerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldTopologyInitializer.GetType());
+      UpdateTopologyParameters();
+    }
+
+    private void UpdateTopologyParameters() {
+      ITopologyUpdater oldTopologyUpdater = TopologyUpdater;
+      IParticleUpdater oldParticleUpdater = ParticleUpdater;
+      ClearTopologyParameters();
+      if (TopologyInitializer != null) {
+        foreach (ITopologyUpdater topologyUpdater in ApplicationManager.Manager.GetInstances<ITopologyUpdater>())
+          TopologyUpdaterParameter.ValidValues.Add(topologyUpdater);
+        foreach (IParticleUpdater particleUpdater in ApplicationManager.Manager.GetInstances<ILocalParticleUpdater>())
+          ParticleUpdaterParameter.ValidValues.Add(particleUpdater);
+      } else {
+        foreach (IParticleUpdater particleUpdater in ApplicationManager.Manager.GetInstances<IGlobalParticleUpdater>())
+          ParticleUpdaterParameter.ValidValues.Add(particleUpdater);
+      }
+      if (oldTopologyUpdater != null) {
+        ITopologyUpdater newTopologyUpdater = TopologyUpdaterParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldParticleUpdater.GetType());
+        if (newTopologyUpdater != null) TopologyUpdater = newTopologyUpdater;
+      }
+      if (oldParticleUpdater != null) {
+        IParticleUpdater newParticleUpdater = ParticleUpdaterParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldParticleUpdater.GetType());
+        if (newParticleUpdater != null) ParticleUpdater = newParticleUpdater;
+      }
+    }
+
+    private void ClearTopologyParameters() {
+      TopologyUpdaterParameter.ValidValues.Clear();
+      ParticleUpdaterParameter.ValidValues.Clear();
+    }
     #endregion
-      
+
   }
 }