Changeset 13404 for branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Analyzers

Timestamp:

11/26/15 09:30:43 (9 years ago)

Author:

abeham

Message:

#2521:

• Adapted Knapsack problem to new problem infrastructure
• Introduced additional interfaces in binary vector encoding
• Improved KnapsackImprovementOperator which requires less evaluated solutions in case of an infeasible start solution

Loosely related change:

• All LookupParameters are now shown by default
• Wiring code should make sure that wired parameters are hidden

File:

• branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Analyzers/BestKnapsackSolutionAnalyzer.cs (modified) (4 diffs)

branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Analyzers/BestKnapsackSolutionAnalyzer.cs

@@ -36 +36 @@
   [Item("BestKnapsackSolutionAnalyzer", "An operator for analyzing the best solution for a Knapsack problem.")]
   [StorableClass]
-  public class BestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator {
+  public class BestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IBinaryVectorSolutionsOperator, IAnalyzer, ISingleObjectiveOperator {
     public virtual bool EnabledByDefault {
       get { return true; }
     }
 
-    public LookupParameter<BoolValue> MaximizationParameter {
-      get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
-    public ScopeTreeLookupParameter<BinaryVector> BinaryVectorParameter {
-      get { return (ScopeTreeLookupParameter<BinaryVector>)Parameters["BinaryVector"]; }
+    public IScopeTreeLookupParameter<BinaryVector> BinaryVectorsParameter {
+      get { return (IScopeTreeLookupParameter<BinaryVector>)Parameters["BinaryVectors"]; }
     }
-    public LookupParameter<IntValue> KnapsackCapacityParameter {
-      get { return (LookupParameter<IntValue>)Parameters["KnapsackCapacity"]; }
+    public ILookupParameter<IntValue> KnapsackCapacityParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["KnapsackCapacity"]; }
     }
-    public LookupParameter<IntArray> WeightsParameter {
-      get { return (LookupParameter<IntArray>)Parameters["Weights"]; }
+    public ILookupParameter<IntArray> WeightsParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["Weights"]; }
     }
-    public LookupParameter<IntArray> ValuesParameter {
-      get { return (LookupParameter<IntArray>)Parameters["Values"]; }
+    public ILookupParameter<IntArray> ValuesParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["Values"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public LookupParameter<KnapsackSolution> BestSolutionParameter {
-      get { return (LookupParameter<KnapsackSolution>)Parameters["BestSolution"]; }
+    public ILookupParameter<KnapsackSolution> BestSolutionParameter {
+      get { return (ILookupParameter<KnapsackSolution>)Parameters["BestSolution"]; }
     }
-    public ValueLookupParameter<ResultCollection> ResultsParameter {
-      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
     }
-    public LookupParameter<DoubleValue> BestKnownQualityParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    public ILookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
     }
-    public LookupParameter<BinaryVector> BestKnownSolutionParameter {
-      get { return (LookupParameter<BinaryVector>)Parameters["BestKnownSolution"]; }
+    public ILookupParameter<BinaryVector> BestKnownSolutionParameter {
+      get { return (ILookupParameter<BinaryVector>)Parameters["BestKnownSolution"]; }
     }
 
@@ -78 +78 @@
       : base() {
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem."));
-      Parameters.Add(new ScopeTreeLookupParameter<BinaryVector>("BinaryVector", "The Knapsack solutions from which the best solution should be visualized."));
+      Parameters.Add(new ScopeTreeLookupParameter<BinaryVector>("BinaryVectors", "The Knapsack solutions from which the best solution should be visualized."));
       Parameters.Add(new LookupParameter<IntValue>("KnapsackCapacity", "Capacity of the Knapsack."));
       Parameters.Add(new LookupParameter<IntArray>("Weights", "The weights of the items."));
@@ -95 +95 @@
 
     public override IOperation Apply() {
-      ItemArray<BinaryVector> binaryVectors = BinaryVectorParameter.ActualValue;
-      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
-      ResultCollection results = ResultsParameter.ActualValue;
-      bool max = MaximizationParameter.ActualValue.Value;
-      DoubleValue bestKnownQuality = BestKnownQualityParameter.ActualValue;
+      var binaryVectors = BinaryVectorsParameter.ActualValue;
+      var qualities = QualityParameter.ActualValue;
+      var results = ResultsParameter.ActualValue;
+      var max = MaximizationParameter.ActualValue.Value;
+      var bestKnownQuality = BestKnownQualityParameter.ActualValue;
 
       int i = -1;
-      if (!max)
-        i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
-      else i = qualities.Select((x, index) => new { index, x.Value }).OrderByDescending(x => x.Value).First().index;
+      i = !max ? qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index
+               : qualities.Select((x, index) => new { index, x.Value }).OrderByDescending(x => x.Value).First().index;
 
       if (bestKnownQuality == null ||
@@ -113 +112 @@
       }
 
-      KnapsackSolution solution = BestSolutionParameter.ActualValue;
+      var solution = BestSolutionParameter.ActualValue;
       if (solution == null) {
         solution = new KnapsackSolution((BinaryVector)binaryVectors[i].Clone(), new DoubleValue(qualities[i].Value),