Changeset 8887 for trunk/sources/HeuristicLab.Problems.Scheduling/3.3/Evaluators

Timestamp:

11/11/12 22:57:09 (12 years ago)

Author:

abeham

Message:

#1329:

• Moved decoders and evaluators from encoding to problem
• Removed unnecessary state variables in operators
• Introduced parameters in interfaces and added wiring code
• Removed ConcreteScheduleManipulator as it does not perform any manipulation
• Made ErrorPolicy and ForcingStrategy configurable and added views for them
• Renamed the SchedulingEvaluationAlgorithm and also converted the AlgorithmOperator to a SingleSuccessorOperator
• Fixed Plugin- and AssemblyFileVersion
• Added missing license headers

Location:

trunk/sources/HeuristicLab.Problems.Scheduling/3.3/Evaluators

Files:

• MakespanEvaluator.cs (modified) (2 diffs)
• MeanTardinessEvaluator.cs (modified) (3 diffs)
• ScheduleEvaluator.cs (added)
• SchedulingEvaluationAlgorithm.cs (deleted)
• SchedulingEvaluator.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.Problems.Scheduling/3.3/Evaluators/MakespanEvaluator.cs

@@ -30 +30 @@
   [Item("Makespan Evaluator", "Represents an evaluator using the maximum makespan of a schedule.")]
   [StorableClass]
-  public class MakespanEvaluator : SchedulingEvaluator {
+  public class MakespanEvaluator : ScheduleEvaluator {
+
     [StorableConstructor]
     protected MakespanEvaluator(bool deserializing) : base(deserializing) { }
-    protected MakespanEvaluator(MakespanEvaluator original, Cloner cloner)
-      : base(original, cloner) {
+    protected MakespanEvaluator(MakespanEvaluator original, Cloner cloner) : base(original, cloner) {}
+    public MakespanEvaluator()
+      : base() {
+      QualityParameter.ActualName = "Makespan";
     }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new MakespanEvaluator(this, cloner);
     }
-
-    public MakespanEvaluator() : base() { }
 
     public static double GetMakespan(Schedule schedule) {
@@ -46 +48 @@
     }
 
-    protected override DoubleValue Evaluate(Schedule schedule) {
-      return new DoubleValue(GetMakespan(schedule));
-    }
-
-    public override IOperation Apply() {
-      return base.Apply();
+    protected override double Evaluate(Schedule schedule) {
+      return GetMakespan(schedule);
     }
   }

trunk/sources/HeuristicLab.Problems.Scheduling/3.3/Evaluators/MeanTardinessEvaluator.cs

@@ -32 +32 @@
   [Item("Mean tardiness Evaluator", "Represents an evaluator using the mean tardiness of a schedule.")]
   [StorableClass]
-  public class MeanTardinessEvaluator : SchedulingEvaluator, IJSSPOperator {
+  public class MeanTardinessEvaluator : ScheduleEvaluator, IJSSPOperator {
 
     [StorableConstructor]
@@ -50 +50 @@
       : base() {
       Parameters.Add(new LookupParameter<ItemList<Job>>("JobData", "Jobdata defining the precedence relationships and the duration of the tasks in this JSSP-Instance."));
+      QualityParameter.ActualName = "MeanTardiness";
     }
 
@@ -58 +59 @@
     }
 
-    protected override DoubleValue Evaluate(Schedule schedule) {
-      return new DoubleValue(GetMeanTardiness(schedule, JobDataParameter.ActualValue));
+    protected override double Evaluate(Schedule schedule) {
+      return GetMeanTardiness(schedule, JobDataParameter.ActualValue);
     }
   }

trunk/sources/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluator.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -28 +29 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
+namespace HeuristicLab.Problems.Scheduling {
+  [Item("SchedulingEvaluator", "First applies the decoder operator to obtain a schedule from an encoding and then applies the evaluator to obtain a quality.")]
+  [StorableClass]
+  public class SchedulingEvaluator : SingleSuccessorOperator, ISchedulingEvaluator {
 
-namespace HeuristicLab.Problems.Scheduling {
-  [Item("Scheduling Evaluator", "Represents a evaluator class for standard scheduling problems.")]
-  [StorableClass]
-  public abstract class SchedulingEvaluator : SingleSuccessorOperator, IScheduleEvaluator {
+    public IValueLookupParameter<IScheduleDecoder> ScheduleDecoderParameter {
+      get { return (IValueLookupParameter<IScheduleDecoder>) Parameters["ScheduleDecoder"]; }
+    }
+    ILookupParameter<IScheduleDecoder> ISchedulingEvaluator.ScheduleDecoderParameter {
+      get { return ScheduleDecoderParameter; }
+    }
+    public IValueLookupParameter<IScheduleEvaluator> ScheduleEvaluatorParameter {
+      get { return (IValueLookupParameter<IScheduleEvaluator>) Parameters["ScheduleEvaluator"]; }
+    }
+    ILookupParameter<IScheduleEvaluator> ISchedulingEvaluator.ScheduleEvaluatorParameter {
+      get { return ScheduleEvaluatorParameter; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
     [StorableConstructor]
     protected SchedulingEvaluator(bool deserializing) : base(deserializing) { }
-    protected SchedulingEvaluator(SchedulingEvaluator original, Cloner cloner)
-      : base(original, cloner) {
+    protected SchedulingEvaluator(SchedulingEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public SchedulingEvaluator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IScheduleDecoder>("ScheduleDecoder", "The decoding operator that is used to calculate a schedule from the used representation."));
+      Parameters.Add(new ValueLookupParameter<IScheduleEvaluator>("ScheduleEvaluator", "The actual schedule evaluation operator."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value aka fitness value of the solution."));
+      QualityParameter.Hidden = true;
     }
 
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get {
-        if (Parameters.ContainsKey("Quality"))
-          return (ILookupParameter<DoubleValue>)Parameters["Quality"];
-        else
-          return null;
-      }
-    }
-    public ILookupParameter<Schedule> ScheduleParameter {
-      get { return (ILookupParameter<Schedule>)Parameters["Schedule"]; }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SchedulingEvaluator(this, cloner);
     }
 
-    public SchedulingEvaluator()
-      : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value aka fitness value of the solution."));
-      Parameters.Add(new LookupParameter<Schedule>("Schedule", "The decoded scheduling solution represented as generalized schedule."));
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
-    }
+    public override IOperation Apply() {
+      var decoder = ScheduleDecoderParameter.ActualValue;
+      var evaluator = ScheduleEvaluatorParameter.ActualValue;
+      if (evaluator == null) throw new InvalidOperationException("A ScheduleEvaluator could not be found.");
 
-    protected abstract DoubleValue Evaluate(Schedule schedule);
-
-    public override IOperation Apply() {
-      Schedule schedule = ScheduleParameter.ActualValue;
-      QualityParameter.ActualValue = Evaluate(schedule);
-      return base.Apply();
+      var operations = new OperationCollection(base.Apply());
+      operations.Insert(0, ExecutionContext.CreateChildOperation(evaluator));
+      if (decoder != null) // decode before evaluating
+        operations.Insert(0, ExecutionContext.CreateChildOperation(decoder));
+      return operations;
     }
   }