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

Timestamp:

01/20/11 01:30:44 (13 years ago)

Author:

cneumuel

Message:

#1215

• made all IAlgorithm types compatible to be loaded into MetaOptimization.
• valid problem types are now automatically set

File:

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

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

@@ -49 +49 @@
 
     #region Parameter Properties
-    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 {
-      get { return (ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>)Parameters[ProblemsParameterName]; }
+    public IValueParameter<ConstrainedTypeValue<IAlgorithm>> AlgorithmTypeParameter {
+      get { return (ValueParameter<ConstrainedTypeValue<IAlgorithm>>)Parameters[AlgorithmTypeParameterName]; }
+    }
+    public IValueParameter<ConstrainedTypeValue<IProblem>> ProblemTypeParameter {
+      get { return (ValueParameter<ConstrainedTypeValue<IProblem>>)Parameters[ProblemTypeParameterName]; }
+    }
+    public IValueParameter<ConstrainedItemList<IProblem>> ProblemsParameter {
+      get { return (ValueParameter<ConstrainedItemList<IProblem>>)Parameters[ProblemsParameterName]; }
     }
     public IValueParameter<ParameterConfigurationTree> ParameterConfigurationTreeParameter {
@@ -75 +75 @@
 
     #region Properties
-    public EngineAlgorithm Algorithm {
+    public IAlgorithm Algorithm {
       get { return CreateAlgorithm(AlgorithmType.Value, ProblemType.Value); }
     }
-    public ConstrainedTypeValue<EngineAlgorithm> AlgorithmType {
+    public ConstrainedTypeValue<IAlgorithm> AlgorithmType {
       get { return AlgorithmTypeParameter.Value; }
       set { AlgorithmTypeParameter.Value = value; }
     }
-    public ConstrainedTypeValue<ISingleObjectiveProblem> ProblemType {
+    public ConstrainedTypeValue<IProblem> ProblemType {
       get { return ProblemTypeParameter.Value; }
       set { ProblemTypeParameter.Value = value; }
     }
-    public ConstrainedItemList<ISingleObjectiveProblem> Problems {
+    public ConstrainedItemList<IProblem> Problems {
       get { return ProblemsParameter.Value; }
       set { ProblemsParameter.Value = value; }
@@ -111 +111 @@
     public MetaOptimizationProblem()
       : base() {
-      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<ConstrainedTypeValue<IAlgorithm>>(AlgorithmTypeParameterName, "The algorithm which's parameters should be optimized.", new ConstrainedTypeValue<IAlgorithm>(typeof(GeneticAlgorithm))));
+      Parameters.Add(new ValueParameter<ConstrainedTypeValue<IProblem>>(ProblemTypeParameterName, "The problem type.", new ConstrainedTypeValue<IProblem>()));
+      Parameters.Add(new ValueParameter<ConstrainedItemList<IProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ConstrainedItemList<IProblem>()));
       Parameters.Add(new ValueParameter<ParameterConfigurationTree>(ParameterConfigurationTreeParameterName, "Tree of algorithm parameters that should be optimized."));
       Parameters.Add(new ValueParameter<IntValue>(RepetitionsParameterName, "The number of evaluations for each problem.", new IntValue(3)));
@@ -137 +137 @@
       ParameterizeOperators();
 
-      ProblemTypeParameter_ValueChanged(this, EventArgs.Empty);
+      AlgorithmTypeParameter_ValueChanged(this, EventArgs.Empty);
     }
 
@@ -222 +222 @@
 
     private void AlgorithmType_ValueChanged(object sender, EventArgs e) {
+      IAlgorithm instance = (IAlgorithm)Activator.CreateInstance(AlgorithmType.Value);
+      this.ProblemType.ValidTypes = ApplicationManager.Manager.GetTypes(instance.ProblemType, true).ToList();
+      this.ProblemType.Value = this.ProblemType.ValidTypes.First();
       ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(CreateAlgorithm(AlgorithmType.Value, ProblemType.Value));
     }
@@ -236 +239 @@
     #endregion
 
-    private EngineAlgorithm CreateAlgorithm(Type algorithmType, Type problemType) {
-      EngineAlgorithm algorithm = (EngineAlgorithm)Activator.CreateInstance(algorithmType);
+    private IAlgorithm CreateAlgorithm(Type algorithmType, Type problemType) {
+      IAlgorithm algorithm = (IAlgorithm)Activator.CreateInstance(algorithmType);
       algorithm.Problem = (IProblem)Activator.CreateInstance(problemType);
       return algorithm;
     }
 
-    public void ImportAlgorithm(EngineAlgorithm algorithm) {
+    public void ImportAlgorithm(IAlgorithm algorithm) {
       AlgorithmType.Value = algorithm.GetType();
-      if(algorithm.Problem != null) ProblemType.Value = algorithm.Problem.GetType();
+      if (algorithm.Problem != null) ProblemType.Value = algorithm.Problem.GetType();
       ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(algorithm);
-      if(algorithm.Problem != null) Problems.Add((ISingleObjectiveProblem)algorithm.Problem);
+      if (algorithm.Problem != null) Problems.Add((IProblem)algorithm.Problem);
     }
   }