Changeset 15562 for branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/Evolutionary/ESContext.cs

Timestamp:

12/29/17 23:56:43 (6 years ago)

Author:

abeham

Message:

#1614: added additional algorithms

Location:

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/Evolutionary

Files:

• . (added)
• ESContext.cs (copied) (copied from branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPContext.cs) (3 diffs)

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/Evolutionary/ESContext.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Threading;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Random;
 
-namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms.GRASP {
-  [Item("GRASP+PR (GQAP) Context", "Context for GRASP+PR (GQAP).")]
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms.Evolutionary {
+  [Item("Evolution Strategy (GQAP) Context", "Context for Evolution Strategies (GQAP).")]
   [StorableClass]
-  public sealed class GRASPContext : ParameterizedNamedItem, IExecutionContext {
+  public sealed class ESContext : SingleObjectivePopulationContext<ISingleObjectiveSolutionScope<ESGQAPSolution>> {
     
-    private IExecutionContext parent;
-    public IExecutionContext Parent {
-      get { return parent; }
-      set { parent = value; }
-    }
-
-    [Storable]
-    private IScope scope;
-    public IScope Scope {
-      get { return scope; }
-      private set { scope = value; }
-    }
-
-    IKeyedItemCollection<string, IParameter> IExecutionContext.Parameters {
-      get { return Parameters; }
-    }
-
     [Storable]
     private IValueParameter<GQAP> problem;
@@ -61 +37 @@
       set { problem.Value = value; }
     }
-    public bool Maximization {
-      get { return Problem.Maximization; }
-    }
 
     [Storable]
-    private IValueParameter<BoolValue> initialized;
-    public bool Initialized {
-      get { return initialized.Value.Value; }
-      set { initialized.Value.Value = value; }
-    }
-
-    [Storable]
-    private IValueParameter<IntValue> iterations;
-    public int Iterations {
-      get { return iterations.Value.Value; }
-      set { iterations.Value.Value = value; }
-    }
-
-    [Storable]
-    private IValueParameter<IntValue> evaluatedSolutions;
-    public int EvaluatedSolutions {
-      get { return evaluatedSolutions.Value.Value; }
-      set { evaluatedSolutions.Value.Value = value; }
-    }
-
-    [Storable]
-    private IValueParameter<DoubleValue> bestQuality;
-    public double BestQuality {
-      get { return bestQuality.Value.Value; }
-      set { bestQuality.Value.Value = value; }
-    }
-
-    [Storable]
-    private IValueParameter<GQAPSolution> bestSolution;
-    public GQAPSolution BestSolution {
+    private IValueParameter<ESGQAPSolution> bestSolution;
+    public ESGQAPSolution BestSolution {
       get { return bestSolution.Value; }
       set { bestSolution.Value = value; }
     }
 
-    [Storable]
-    private IValueParameter<IntValue> localSearchEvaluations;
-    public int LocalSearchEvaluations {
-      get { return localSearchEvaluations.Value.Value; }
-      set { localSearchEvaluations.Value.Value = value; }
-    }
-    
-    [Storable]
-    private IValueParameter<IRandom> random;
-    public IRandom Random {
-      get { return random.Value; }
-      set { random.Value = value; }
-    }
-
-    public IEnumerable<ISingleObjectiveSolutionScope<GQAPSolution>> Population {
-      get { return scope.SubScopes.OfType<ISingleObjectiveSolutionScope<GQAPSolution>>(); }
-    }
-    public void AddToPopulation(ISingleObjectiveSolutionScope<GQAPSolution> solScope) {
-      scope.SubScopes.Add(solScope);
-    }
-    public void ReplaceAtPopulation(int index, ISingleObjectiveSolutionScope<GQAPSolution> solScope) {
-      scope.SubScopes[index] = solScope;
-    }
-    public ISingleObjectiveSolutionScope<GQAPSolution> AtPopulation(int index) {
-      return scope.SubScopes[index] as ISingleObjectiveSolutionScope<GQAPSolution>;
-    }
-    public void SortPopulation() {
-      scope.SubScopes.Replace(scope.SubScopes.OfType<ISingleObjectiveSolutionScope<GQAPSolution>>().OrderBy(x => Maximization ? -x.Fitness : x.Fitness).ToList());
-    }
-    public int PopulationCount {
-      get { return scope.SubScopes.Count; }
+    public void ReplacePopulation(IEnumerable<ISingleObjectiveSolutionScope<ESGQAPSolution>> replacement) {
+      Scope.SubScopes.Replace(replacement);
     }
     
     [StorableConstructor]
-    private GRASPContext(bool deserializing) : base(deserializing) { }
-    private GRASPContext(GRASPContext original, Cloner cloner)
+    private ESContext(bool deserializing) : base(deserializing) { }
+    private ESContext(ESContext original, Cloner cloner)
       : base(original, cloner) {
-      scope = cloner.Clone(original.scope);
       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);
-      localSearchEvaluations = cloner.Clone(original.localSearchEvaluations);
-      random = cloner.Clone(original.random);
     }
-    public GRASPContext() : this("GRASP+PR (GQAP) Context") { }
-    public GRASPContext(string name) : base(name) {
-      scope = new Scope("Global");
-
+    public ESContext() : this("Evolution Strategy (GQAP) Context") { }
+    public ESContext(string name) : base(name) {
       Parameters.Add(problem = new ValueParameter<GQAP>("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<GQAPSolution>("BestFoundSolution"));
-      Parameters.Add(localSearchEvaluations = new ValueParameter<IntValue>("LocalSearchEvaluations", new IntValue(0)));
-      Parameters.Add(random = new ValueParameter<IRandom>("Random", new MersenneTwister()));
+      Parameters.Add(bestSolution = new ValueParameter<ESGQAPSolution>("BestFoundSolution"));
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new GRASPContext(this, cloner);
+      return new ESContext(this, cloner);
     }
 
-    public ISingleObjectiveSolutionScope<GQAPSolution> ToScope(GQAPSolution code, double fitness = double.NaN) {
+    public ISingleObjectiveSolutionScope<ESGQAPSolution> ToScope(ESGQAPSolution code, double fitness = double.NaN) {
       var name = Problem.Encoding.Name;
-      var scope = new SingleObjectiveSolutionScope<GQAPSolution>(code,
+      var scope = new SingleObjectiveSolutionScope<ESGQAPSolution>(code,
         name + "Solution", fitness, Problem.Evaluator.QualityParameter.ActualName) {
         Parent = Scope
@@ -175 +76 @@
       return scope;
     }
-
-    public void IncrementEvaluatedSolutions(int byEvaluations) {
-      if (byEvaluations < 0) throw new ArgumentException("Can only increment and not decrement evaluated solutions.");
-      EvaluatedSolutions += byEvaluations;
-    }
-    
-    private static void ExecuteAlgorithm(IAlgorithm algorithm) {
-      using (var evt = new AutoResetEvent(false)) {
-        EventHandler exeStateChanged = (o, args) => {
-          if (algorithm.ExecutionState != ExecutionState.Started)
-            evt.Set();
-        };
-        algorithm.ExecutionStateChanged += exeStateChanged;
-        if (algorithm.ExecutionState != ExecutionState.Prepared) {
-          algorithm.Prepare(true);
-          evt.WaitOne();
-        }
-        algorithm.Start();
-        evt.WaitOne();
-        algorithm.ExecutionStateChanged -= exeStateChanged;
-      }
-    }
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool IsBetter(ISingleObjectiveSolutionScope<GQAPSolution> a, ISingleObjectiveSolutionScope<GQAPSolution> b) {
-      return IsBetter(a.Fitness, b.Fitness);
-    }
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool IsBetter(double a, double b) {
-      return double.IsNaN(b) && !double.IsNaN(a)
-        || Maximization && a > b
-        || !Maximization && a < b;
-    }
-
-    #region IExecutionContext members
-    public IAtomicOperation CreateOperation(IOperator op) {
-      return new Core.ExecutionContext(this, op, Scope);
-    }
-
-    public IAtomicOperation CreateOperation(IOperator op, IScope s) {
-      return new Core.ExecutionContext(this, op, s);
-    }
-
-    public IAtomicOperation CreateChildOperation(IOperator op) {
-      return new Core.ExecutionContext(this, op, Scope);
-    }
-
-    public IAtomicOperation CreateChildOperation(IOperator op, IScope s) {
-      return new Core.ExecutionContext(this, op, s);
-    }
-    #endregion
-
-    #region Engine Helper
-    public void RunOperator(IOperator op, IScope scope, CancellationToken cancellationToken) {
-      var stack = new Stack<IOperation>();
-      stack.Push(CreateChildOperation(op, scope));
-
-      while (stack.Count > 0) {
-        cancellationToken.ThrowIfCancellationRequested();
-
-        var next = stack.Pop();
-        if (next is OperationCollection) {
-          var coll = (OperationCollection)next;
-          for (int i = coll.Count - 1; i >= 0; i--)
-            if (coll[i] != null) stack.Push(coll[i]);
-        } else if (next is IAtomicOperation) {
-          var operation = (IAtomicOperation)next;
-          try {
-            next = operation.Operator.Execute((IExecutionContext)operation, cancellationToken);
-          } catch (Exception ex) {
-            stack.Push(operation);
-            if (ex is OperationCanceledException) throw ex;
-            else throw new OperatorExecutionException(operation.Operator, ex);
-          }
-          if (next != null) stack.Push(next);
-        }
-      }
-    }
-    #endregion
   }
 }