Changeset 13396 for branches/ProblemRefactoring/HeuristicLab.Optimization

Timestamp:

11/25/15 16:22:37 (9 years ago)

Author:

abeham

Message:

#2521:

• Refactored QuadraticAssignmentProblem to use new SingleObjectiveProblem
  • Removed QAPEvaluator
  • Adapted RobustTabooSearch
• Introduced several interfaces in PermutationEncoding necessary for wiring
• Changed all Encodings to use IItem instead of IOperator in ConfigureOperators (name still unchanged)
• Added a protected MaximizationParameter property in SingleObjectiveProblem (necessary for wiring)
• Changed AlleleFrequnencyAnalyzer to use ISolution interface instead of IItem
• Added a comment to ISolutionCreator<TSolution> of some changes that would be welcomed

Location:

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3

Files:

• BasicProblems/CombinedEncoding.cs (modified) (1 diff)
• BasicProblems/Encoding.cs (modified) (1 diff)
• BasicProblems/Interfaces/IEncoding.cs (modified) (1 diff)
• BasicProblems/Problem.cs (modified) (2 diffs)
• BasicProblems/SingleObjectiveProblem.cs (modified) (2 diffs)
• Interfaces/ISolutionCreator.cs (modified) (1 diff)

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/CombinedEncoding.cs

@@ -88 +88 @@
     }
 
-    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
       foreach (var encOp in operators.OfType<IMultiEncodingOperator>())
         encOp.SolutionParameter.ActualName = Name;

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs

@@ -100 +100 @@
     }
 
-    public void ConfigureOperator(IOperator @operator) { ConfigureOperators(new[] { @operator }); }
-    public abstract void ConfigureOperators(IEnumerable<IOperator> operators);
+    public void ConfigureOperator(IItem @operator) { ConfigureOperators(new[] { @operator }); }
+    public abstract void ConfigureOperators(IEnumerable<IItem> operators);
 
     public event EventHandler SolutionCreatorChanged;

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs

@@ -29 +29 @@
     IEnumerable<IOperator> Operators { get; set; }
 
-    void ConfigureOperator(IOperator @operator);
-    void ConfigureOperators(IEnumerable<IOperator> operators);
+    void ConfigureOperator(IItem @operator);
+    void ConfigureOperators(IEnumerable<IItem> operators);
 
     event EventHandler SolutionCreatorChanged;

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs

@@ -35 +35 @@
     where TEvaluator : class, IEvaluator {
 
-    public string Filename { get; set; }
+    public string Filename { get; set; } // TODO: Really okay here?
 
     protected IValueParameter<TEncoding> EncodingParameter {
@@ -71 +71 @@
         Parameterize();
       }
+      RegisterEvents();
+    }
+    protected Problem(TEncoding encoding) {
+      if (encoding == null) throw new ArgumentNullException("encoding");
+      Parameters.Add(new ValueParameter<TEncoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any.", encoding));
+      oldEncoding = Encoding;
+      SolutionCreator = Encoding.SolutionCreator;
+      Parameterize();
+
       RegisterEvents();
     }

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs

@@ -41 +41 @@
     }
 
+    protected IFixedValueParameter<BoolValue> MaximizationParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
     public double BestKnownQuality {
       get {
@@ -62 +66 @@
     protected SingleObjectiveProblem()
       : base() {
+      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
+      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
+
+      Operators.Add(Evaluator);
+      Operators.Add(new SingleObjectiveAnalyzer<TSolution>());
+      Operators.Add(new SingleObjectiveImprover<TSolution>());
+      Operators.Add(new SingleObjectiveMoveEvaluator<TSolution>());
+      Operators.Add(new SingleObjectiveMoveGenerator<TSolution>());
+      Operators.Add(new SingleObjectiveMoveMaker<TSolution>());
+
+      ParameterizeOperators();
+    }
+
+    protected SingleObjectiveProblem(TEncoding encoding)
+      : base(encoding) {
       Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
       Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs

@@ -28 +28 @@
   public interface ISolutionCreator : IOperator { }
 
-  public interface ISolutionCreator<TSolution> : ISolutionCreator where TSolution : class, ISolution { }
+  public interface ISolutionCreator<TSolution> : ISolutionCreator where TSolution : class, ISolution {
+    //ILookupParameter<TSolution> SolutionParameter { get; } // TODO: unify encoding specific parameters by defining ISolutionOperator and ISolutionsOperator
+  }
 }