Changeset 5313 for branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs

Timestamp:

01/17/11 19:17:51 (13 years ago)

Author:

cneumuel

Message:

#1215

• changed AlgorithType and ProblemType to actually be types not objects. this eliminates redundant views for MetaOptimizationProblem
• import algorithm for MetaOptimizationProblem
• nicer dialog for combination creation
• fixed iconimage for ParameterConfigurations
• fixed ValidValues

File:

• branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs (modified) (8 diffs)

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs

@@ -40 +40 @@
     public const string ProblemTypeParameterName = "ProblemType";
     public const string ProblemsParameterName = "Problems";
-    public const string ParameterConfigurationTreeParameterName = "InitialParameterConfigurationTree";
+    public const string ParameterConfigurationTreeParameterName = "ParameterConfigurationTree";
     public const string RepetitionsParameterName = "Repetitions";
 
@@ -49 +49 @@
 
     #region Parameter Properties
-    public IValueParameter<EngineAlgorithm> AlgorithmTypeParameter {
-      get { return (ValueParameter<EngineAlgorithm>)Parameters[AlgorithmTypeParameterName]; }
-    }
-    public IValueParameter<ISingleObjectiveProblem> ProblemTypeParameter {
-      get { return (ValueParameter<ISingleObjectiveProblem>)Parameters[ProblemTypeParameterName]; }
+    public IValueParameter<ConstrainedTypeValue<EngineAlgorithm>> AlgorithmTypeParameter {
+      get { return (ValueParameter<ConstrainedTypeValue<EngineAlgorithm>>)Parameters[AlgorithmTypeParameterName]; }
+    }
+    public IValueParameter<ConstrainedTypeValue<ISingleObjectiveProblem>> ProblemTypeParameter {
+      get { return (ValueParameter<ConstrainedTypeValue<ISingleObjectiveProblem>>)Parameters[ProblemTypeParameterName]; }
     }
     public IValueParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
@@ -76 +76 @@
     #region Properties
     public EngineAlgorithm Algorithm {
+      get { return CreateAlgorithm(AlgorithmType.Value, ProblemType.Value); }
+    }
+    public ConstrainedTypeValue<EngineAlgorithm> AlgorithmType {
       get { return AlgorithmTypeParameter.Value; }
       set { AlgorithmTypeParameter.Value = value; }
     }
-    public ISingleObjectiveProblem Problem {
+    public ConstrainedTypeValue<ISingleObjectiveProblem> ProblemType {
       get { return ProblemTypeParameter.Value; }
       set { ProblemTypeParameter.Value = value; }
@@ -108 +111 @@
     public MetaOptimizationProblem()
       : base() {
-      Parameters.Add(new ValueParameter<EngineAlgorithm>(AlgorithmTypeParameterName, "The algorithm which's parameters should be optimized.", new GeneticAlgorithm()));
-      Parameters.Add(new ValueParameter<ISingleObjectiveProblem>(ProblemTypeParameterName, "The problem type.", new SingleObjectiveTestFunctionProblem()));
+      Parameters.Add(new ValueParameter<ConstrainedTypeValue<EngineAlgorithm>>(AlgorithmTypeParameterName, "The algorithm which's parameters should be optimized.", new ConstrainedTypeValue<EngineAlgorithm>(typeof(GeneticAlgorithm))));
+      Parameters.Add(new ValueParameter<ConstrainedTypeValue<ISingleObjectiveProblem>>(ProblemTypeParameterName, "The problem type.", new ConstrainedTypeValue<ISingleObjectiveProblem>(typeof(SingleObjectiveTestFunctionProblem))));
       Parameters.Add(new ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ConstrainedItemList<ISingleObjectiveProblem>()));
       Parameters.Add(new ValueParameter<ParameterConfigurationTree>(ParameterConfigurationTreeParameterName, "Tree of algorithm parameters that should be optimized."));
@@ -134 +137 @@
       ParameterizeOperators();
 
-      Problems.Type = Problem.GetType();
-      Algorithm.Problem = Problem;
-      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
+      ProblemTypeParameter_ValueChanged(this, EventArgs.Empty);
     }
 
@@ -143 +144 @@
     private MetaOptimizationProblem(MetaOptimizationProblem original, Cloner cloner)
       : base(original, cloner) {
-      // todo
       this.RegisterParameterEvents();
     }
@@ -160 +160 @@
       Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
       AlgorithmTypeParameter.ValueChanged += new EventHandler(AlgorithmTypeParameter_ValueChanged);
+      AlgorithmType.ValueChanged += new EventHandler(AlgorithmType_ValueChanged);
       ProblemTypeParameter.ValueChanged += new EventHandler(ProblemTypeParameter_ValueChanged);
+      ProblemType.ValueChanged += new EventHandler(ProblemType_ValueChanged);
     }
 
@@ -215 +217 @@
       ParameterizeAnalyzer();
     }
-    void AlgorithmTypeParameter_ValueChanged(object sender, EventArgs e) {
-      Algorithm.Problem = Problem;
-      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
-    }
-    void ProblemTypeParameter_ValueChanged(object sender, EventArgs e) {
-      Problems.Type = Problem.GetType();
-      Algorithm.Problem = Problem;
-      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
-    }
-    #endregion
+    private void AlgorithmTypeParameter_ValueChanged(object sender, EventArgs e) {
+      AlgorithmType_ValueChanged(sender, e);
+    }
+
+    private void AlgorithmType_ValueChanged(object sender, EventArgs e) {
+      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(CreateAlgorithm(AlgorithmType.Value, ProblemType.Value));
+    }
+
+    private void ProblemTypeParameter_ValueChanged(object sender, EventArgs e) {
+      ProblemType_ValueChanged(sender, e);
+    }
+
+    private void ProblemType_ValueChanged(object sender, EventArgs e) {
+      Problems.Clear();
+      Problems.Type = ProblemType.Value;
+      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(CreateAlgorithm(AlgorithmType.Value, ProblemType.Value));
+    }
+    #endregion
+
+    private EngineAlgorithm CreateAlgorithm(Type algorithmType, Type problemType) {
+      EngineAlgorithm algorithm = (EngineAlgorithm)Activator.CreateInstance(algorithmType);
+      algorithm.Problem = (IProblem)Activator.CreateInstance(problemType);
+      return algorithm;
+    }
+
+    public void ImportAlgorithm(EngineAlgorithm algorithm) {
+      AlgorithmType.Value = algorithm.GetType();
+      if(algorithm.Problem != null) ProblemType.Value = algorithm.Problem.GetType();
+      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(algorithm);
+      if(algorithm.Problem != null) Problems.Add((ISingleObjectiveProblem)algorithm.Problem);
+    }
   }
 }