Changeset 11187

Timestamp:

07/14/14 13:21:16 (10 years ago)

Author:

pfleck

Message:

#2208

• Added Operators in Problem.
• Implemented simple OrienteeringEvaluator.

Location:

branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3

Files:

• DistanceMatrix.cs (added)
• Evaluators/OrienteeringEvaluator.cs (modified) (3 diffs)
• HeuristicLab.Problems.Orienteering-3.3.csproj (modified) (1 diff)
• OrienteeringProblem.cs (modified) (6 diffs)

branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Evaluators/OrienteeringEvaluator.cs

@@ -23 +23 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
@@ -31 +32 @@
     public ILookupParameter<DoubleValue> QualityParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<IntegerVector> SolutionParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["Solution"]; }
+    }
+    public ILookupParameter<DoubleArray> ScoresParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Scores"]; }
     }
 
@@ -46 +53 @@
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the Orienteering solution."));
-      // TODO
+      Parameters.Add(new LookupParameter<IntegerVector>("Solution", "The Orienteering Solution given in path representation."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Scores", "The scores of the points."));
     }
 
-    public struct OrienteeringEvaluation {
+    public class OrienteeringEvaluation {
       public DoubleValue Quality;
     }
 
-    public static OrienteeringEvaluation Apply() {
-      // TODO
-      return default(OrienteeringEvaluation);
+    public static OrienteeringEvaluation Apply(IntegerVector solution, DoubleArray scores) {
+      // TODO distance penalty
+      double score = 0.0;
+
+      for (int i = 0; i < solution.Length; i++) {
+        score += scores[i];
+      }
+
+      return new OrienteeringEvaluation {
+        Quality = new DoubleValue(score)
+      };
     }
 
     public override IOperation InstrumentedApply() {
-      // TODO
-      var evaluation = Apply();
+      var evaluation = Apply(SolutionParameter.ActualValue, ScoresParameter.ActualValue);
+
+      QualityParameter.ActualValue = evaluation.Quality;
 
       return base.InstrumentedApply();

branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/HeuristicLab.Problems.Orienteering-3.3.csproj

@@ -46 +46 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="DistanceMatrix.cs" />
     <Compile Include="Interfaces\IOrienteeringEvaluator.cs" />
     <Compile Include="Evaluators\OrienteeringEvaluator.cs" />

branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/OrienteeringProblem.cs

@@ -23 +23 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -38 +40 @@
     public string Filename { get; set; }
 
+    #region Parameter Properties
+    public OptionalValueParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (OptionalValueParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    }
+    public OptionalValueParameter<DistanceMatrix> DistanceMatrixParameter {
+      get { return (OptionalValueParameter<DistanceMatrix>)Parameters["DistanceMatrix"]; }
+    }
+    public ValueParameter<BoolValue> UseDistanceMatrixParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
+    }
+
+    public ValueParameter<IntValue> StartingPointParameter {
+      get { return (ValueParameter<IntValue>)Parameters["StartingPoint"]; }
+    }
+    public ValueParameter<IntValue> TerminusPointParameter {
+      get { return (ValueParameter<IntValue>)Parameters["TerminusPoint"]; }
+    }
+    public ValueParameter<DoubleValue> MaximumDistanceParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["MaximumDistance"]; }
+    }
+    public ValueParameter<DoubleArray> ScoresParameter {
+      get { return (ValueParameter<DoubleArray>)Parameters["Scores"]; }
+    }
+    public ValueParameter<DoubleValue> FixedPenaltyParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["FixedPenalty"]; }
+    }
+
+    public OptionalValueParameter<IntegerVector> BestKnownSolutionParameter {
+      get { return (OptionalValueParameter<IntegerVector>)Parameters["BestKnownSolution"]; }
+    }
+    #endregion
+
+    #region Properties
+    public DoubleMatrix Coordinates {
+      get { return CoordinatesParameter.Value; }
+      set { CoordinatesParameter.Value = value; }
+    }
+    public DistanceMatrix DistanceMatrix {
+      get { return DistanceMatrixParameter.Value; }
+      set { DistanceMatrixParameter.Value = value; }
+    }
+    public BoolValue UseDistanceMatrix {
+      get { return UseDistanceMatrixParameter.Value; }
+      set { UseDistanceMatrixParameter.Value = value; }
+    }
+    public DoubleValue MaximumDistance {
+      get { return MaximumDistanceParameter.Value; }
+      set { MaximumDistanceParameter.Value = value; }
+    }
+    public DoubleArray Scores {
+      get { return ScoresParameter.Value; }
+      set { ScoresParameter.Value = value; }
+    }
+    public IntegerVector BestKnownSolution {
+      get { return BestKnownSolutionParameter.Value; }
+      set { BestKnownSolutionParameter.Value = value; }
+    }
+    #endregion
+
     [StorableConstructor]
     private OrienteeringProblem(bool deserializing)
@@ -55 +116 @@
     public OrienteeringProblem()
       : base(new OrienteeringEvaluator(), new UniformRandomIntegerVectorCreator()) {
-      // TODO: Parameters
+      Parameters.Add(new OptionalValueParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the points."));
+      Parameters.Add(new OptionalValueParameter<DistanceMatrix>("DistanceMatrix", "The matrix which contains the distances between the points."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseDistanceMatrix", "True if the coordinates based evaluators should calculate the distance matrix from the coordinates and use it for evaluation similar to the distance matrix evaluator, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<IntValue>("StartingPoint", "Index of the starting point.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<IntValue>("TerminusPoint", "Index of the ending point.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("MaximumDistance", "The maximum distance constraint for a Orienteering solution."));
+      Parameters.Add(new ValueParameter<DoubleArray>("Scores", "The scores of the points.", new DoubleArray()));
+      Parameters.Add(new ValueParameter<DoubleValue>("FixedPenalty", "The penalty for each visited vertex."));
+      Parameters.Add(new OptionalValueParameter<IntegerVector>("BestKnownSolution", "The best known solution of this Orienteering instance."));
 
       Maximization.Value = true;
@@ -71 +140 @@
     }
 
-    #region events
+    #region Events
     protected override void OnSolutionCreatorChanged() {
       base.OnSolutionCreatorChanged();
@@ -100 +169 @@
     private void RegisterEventHandlers() {
       SolutionCreator.IntegerVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_IntegerVectorParameter_ActualNameChanged);
+      // TODO
     }
     private void ParameterizeSolutionCreator() {
-      // TODO
+      if (SolutionCreator.LengthParameter.Value == null
+          || SolutionCreator.LengthParameter.Value.Value != Scores.Length) {
+        SolutionCreator.LengthParameter.Value = new IntValue(Scores.Length);
+      }
     }
     private void ParameterizeEvaluator() {
@@ -111 +184 @@
     }
     private void ParameterizeAnalyzer() {
-      // TODO  
+      // TODO
     }
     private void InitializeOperators() {