Changeset 14450 for branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRContext.cs

Timestamp:

12/03/16 00:32:09 (8 years ago)

Author:

abeham

Message:

#2701: working on MemPR implementation

File:

• branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRContext.cs (modified) (13 diffs)

branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRContext.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
+using HeuristicLab.Algorithms.MemPR.Interfaces;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Optimization;
-using HeuristicLab.Optimization.SolutionModel;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -35 +35 @@
   [Item("MemPRContext", "Abstract base class for MemPR contexts.")]
   [StorableClass]
-  public abstract class MemPRContext<TSolution, TContext, TSolutionContext> : ParameterizedNamedItem,
-      ISingleObjectivePopulationContext<TSolution>, ISolutionModelContext<TSolution>, IStochasticContext,
-      IMaximizationContext, IEvaluatedSolutionsContext
+  public abstract class MemPRPopulationContext<TProblem, TSolution, TPopulationContext, TSolutionContext> : ParameterizedNamedItem,
+    IPopulationBasedHeuristicAlgorithmContext<TProblem, TSolution>, ISolutionModelContext<TSolution>
+      where TProblem : class, IItem, ISingleObjectiveProblemDefinition
       where TSolution : class, IItem
-      where TContext : MemPRContext<TSolution, TContext, TSolutionContext>
-      where TSolutionContext : SingleSolutionMemPRContext<TSolution, TContext, TSolutionContext> {
+      where TPopulationContext : MemPRPopulationContext<TProblem, TSolution, TPopulationContext, TSolutionContext>
+      where TSolutionContext : MemPRSolutionContext<TProblem, TSolution, TPopulationContext, TSolutionContext> {
 
     private IExecutionContext parent;
@@ -60 +60 @@
 
     [Storable]
-    private IValueParameter<BoolValue> maximization;
-    public bool Maximization {
-      get { return maximization.Value.Value; }
-      set { maximization.Value.Value = value; }
+    private IValueParameter<TProblem> problem;
+    public TProblem Problem {
+      get { return problem.Value; }
+      set { problem.Value = value; }
     }
 
@@ -95 +95 @@
 
     [Storable]
+    private IValueParameter<TSolution> bestSolution;
+    public TSolution BestSolution {
+      get { return bestSolution.Value; }
+      set { bestSolution.Value = value; }
+    }
+
+    [Storable]
     private IValueParameter<IntValue> hcSteps;
     public int HcSteps {
@@ -142 +149 @@
       set { random.Value = value; }
     }
-
-    IEnumerable<IScope> IPopulationContext.Population {
-      get { return scope.SubScopes; }
-    }
     
     public IEnumerable<ISingleObjectiveSolutionScope<TSolution>> Population {
@@ -183 +186 @@
 
     [StorableConstructor]
-    protected MemPRContext(bool deserializing) : base(deserializing) { }
-    protected MemPRContext(MemPRContext<TSolution, TContext, TSolutionContext> original, Cloner cloner)
+    protected MemPRPopulationContext(bool deserializing) : base(deserializing) { }
+    protected MemPRPopulationContext(MemPRPopulationContext<TProblem, TSolution, TPopulationContext, TSolutionContext> original, Cloner cloner)
       : base(original, cloner) {
       scope = cloner.Clone(original.scope);
-      maximization = cloner.Clone(original.maximization);
+      problem = cloner.Clone(original.problem);
       initialized = cloner.Clone(original.initialized);
       iterations = cloner.Clone(original.iterations);
       evaluatedSolutions = cloner.Clone(original.evaluatedSolutions);
       bestQuality = cloner.Clone(original.bestQuality);
+      bestSolution = cloner.Clone(original.bestSolution);
       hcSteps = cloner.Clone(original.hcSteps);
       byBreeding = cloner.Clone(original.byBreeding);
@@ -205 +209 @@
       Model = cloner.Clone(original.Model);
     }
-    public MemPRContext() : this("MemPRContext") { }
-    public MemPRContext(string name) : base(name) {
+    public MemPRPopulationContext() : this("MemPRContext") { }
+    public MemPRPopulationContext(string name) : base(name) {
       scope = new Scope("Global");
 
-      Parameters.Add(maximization = new ValueParameter<BoolValue>("Maximization", new BoolValue(false)));
+      Parameters.Add(problem = new ValueParameter<TProblem>("Problem"));
       Parameters.Add(initialized = new ValueParameter<BoolValue>("Initialized", new BoolValue(false)));
       Parameters.Add(iterations = new ValueParameter<IntValue>("Iterations", new IntValue(0)));
       Parameters.Add(evaluatedSolutions = new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(0)));
       Parameters.Add(bestQuality = new ValueParameter<DoubleValue>("BestQuality", new DoubleValue(double.NaN)));
+      Parameters.Add(bestSolution = new ValueParameter<TSolution>("BestSolution"));
       Parameters.Add(hcSteps = new ValueParameter<IntValue>("HcSteps", new IntValue(0)));
       Parameters.Add(byBreeding = new ValueParameter<IntValue>("ByBreeding", new IntValue(0)));
@@ -229 +234 @@
     public abstract TSolutionContext CreateSingleSolutionContext(ISingleObjectiveSolutionScope<TSolution> solution);
 
+    public void IncrementEvaluatedSolutions(int byEvaluations) {
+      if (byEvaluations < 0) throw new ArgumentException("Can only increment and not decrement evaluated solutions.");
+      EvaluatedSolutions += byEvaluations;
+    }
+
     #region IExecutionContext members
     public IAtomicOperation CreateOperation(IOperator op) {
@@ -246 +256 @@
     }
     #endregion
-
-    IEnumerable<ISolutionScope<TSolution>> IPopulationContext<TSolution>.Population {
-      get { return Population; }
-    }
   }
 
   [Item("SingleSolutionMemPRContext", "Abstract base class for single solution MemPR contexts.")]
   [StorableClass]
-  public abstract class SingleSolutionMemPRContext<TSolution, TContext, TSolutionContext> : ParameterizedNamedItem,
-      ISingleObjectiveSolutionContext<TSolution>, IEvaluatedSolutionsContext,
-      IIterationsManipulationContext, IStochasticContext, IMaximizationContext
+  public abstract class MemPRSolutionContext<TProblem, TSolution, TContext, TSolutionContext> : ParameterizedNamedItem,
+    ISingleSolutionHeuristicAlgorithmContext<TProblem, TSolution>
+      where TProblem : class, IItem, ISingleObjectiveProblemDefinition
       where TSolution : class, IItem
-      where TContext : MemPRContext<TSolution, TContext, TSolutionContext>
-      where TSolutionContext : SingleSolutionMemPRContext<TSolution, TContext, TSolutionContext> {
+      where TContext : MemPRPopulationContext<TProblem, TSolution, TContext, TSolutionContext>
+      where TSolutionContext : MemPRSolutionContext<TProblem, TSolution, TContext, TSolutionContext> {
 
     private TContext parent;
@@ -276 +282 @@
       get { return Parameters; }
     }
-    
-    public bool Maximization {
-      get { return parent.Maximization; }
+
+    public TProblem Problem {
+      get { return parent.Problem; }
+    }
+
+    public double BestQuality {
+      get { return parent.BestQuality; }
+      set { parent.BestQuality = value; }
+    }
+
+    public TSolution BestSolution {
+      get { return parent.BestSolution; }
+      set { parent.BestSolution = value; }
     }
 
@@ -299 +315 @@
     }
 
-    IScope ISolutionContext.Solution {
+    ISingleObjectiveSolutionScope<TSolution> ISingleSolutionHeuristicAlgorithmContext<TProblem, TSolution>.Solution {
       get { return scope; }
     }
 
-    ISolutionScope<TSolution> ISolutionContext<TSolution>.Solution {
-      get { return scope; }
-    }
-
-    ISingleObjectiveSolutionScope<TSolution> ISingleObjectiveSolutionContext<TSolution>.Solution {
-      get { return scope; }
-    }
-
     [StorableConstructor]
-    protected SingleSolutionMemPRContext(bool deserializing) : base(deserializing) { }
-    protected SingleSolutionMemPRContext(SingleSolutionMemPRContext<TSolution, TContext, TSolutionContext> original, Cloner cloner)
+    protected MemPRSolutionContext(bool deserializing) : base(deserializing) { }
+    protected MemPRSolutionContext(MemPRSolutionContext<TProblem, TSolution, TContext, TSolutionContext> original, Cloner cloner)
       : base(original, cloner) {
       scope = cloner.Clone(original.scope);
@@ -319 +327 @@
       iterations = cloner.Clone(original.iterations);
     }
-    public SingleSolutionMemPRContext(TContext baseContext, ISingleObjectiveSolutionScope<TSolution> solution) {
+    public MemPRSolutionContext(TContext baseContext, ISingleObjectiveSolutionScope<TSolution> solution) {
       parent = baseContext;
       scope = solution;
@@ -327 +335 @@
     }
 
+    public void IncrementEvaluatedSolutions(int byEvaluations) {
+      if (byEvaluations < 0) throw new ArgumentException("Can only increment and not decrement evaluated solutions.");
+      EvaluatedSolutions += byEvaluations;
+    }
+
     #region IExecutionContext members
     public IAtomicOperation CreateOperation(IOperator op) {