Changeset 14035 for branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3

Timestamp:

07/11/16 14:32:35 (8 years ago)

Author:

abeham

Message:

#2431:

• Fixed bug that occurs when runs of unequal length are aggregated over multiple problem instances

File:

• branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs (modified) (8 diffs)

branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs

@@ -324 +324 @@
       var lineStyleCount = 0;
 
+      var maxEfforts = new Dictionary<ProblemDescription, double>();
+      foreach (var group in groupedRuns) {
+        foreach (var problem in group.Value) {
+          double eff;
+          if (!maxEfforts.TryGetValue(problem.Key, out eff)) {
+            eff = 0.0;
+          }
+          foreach (var run in problem.Value.Item2) {
+            var maxEff = ((IndexedDataTable<double>)run.Results[table]).Rows.First().Values.Last().Item1;
+            if (maxEff > eff) eff = maxEff;
+          }
+          maxEfforts[problem.Key] = eff;
+        }
+      }
+      // if the group contains multiple different problems we want to use the minimal maximal observed effort
+      // otherwise we run into situations where we don't have data for a certain problem instance anymore
+      // this is a special case when aggregating over multiple problem instances
+      var maxEffort = maxEfforts.Values.Min();
+
       foreach (var group in groupedRuns) {
         // hits describes the number of target hits at a certain time for a certain group
@@ -340 +359 @@
 
             if (eachOrAllTargetCheckBox.Checked) {
-              CalculateHitsForEachTarget(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1);
+              CalculateHitsForEachTarget(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, maxEffort);
               // achiving each target can be seen as a separate run for that target only
               noRuns += targets.Length;
             } else {
-              var length = CalculateHitsForAllTargets(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1);
+              var length = CalculateHitsForAllTargets(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, maxEffort);
               maxLength = Math.Max(length, maxLength);
               noRuns++;
@@ -403 +422 @@
                                             Dictionary<string, SortedList<double, int>> misses,
                                             IndexedDataRow<double> row, ProblemDescription problem,
-                                            string group, double bestTarget) {
+                                            string group, double bestTarget, double maxEffort) {
       foreach (var l in targets.Select(x => (problem.IsMaximization() ? (1 - x) : (1 + x)) * bestTarget)) {
         var key = group + "-" + l;
@@ -412 +431 @@
         var hit = false;
         foreach (var v in row.Values) {
+          if (v.Item1 > maxEffort) break;
           if (problem.IsMaximization() && v.Item2 >= l || !problem.IsMaximization() && v.Item2 <= l) {
             if (hits[key].ContainsKey(v.Item1))
@@ -421 +441 @@
         }
         if (!hit) {
-          var max = row.Values.Last();
-          if (misses[key].ContainsKey(max.Item1))
-            misses[key][max.Item1]++;
-          else misses[key][max.Item1] = 1;
+          var max = Math.Min(row.Values.Last().Item1, maxEffort);
+          if (misses[key].ContainsKey(max))
+            misses[key][max]++;
+          else misses[key][max] = 1;
         }
       }
@@ -432 +452 @@
                                               Dictionary<string, SortedList<double, int>> misses,
                                               IndexedDataRow<double> row, ProblemDescription problem,
-                                              string group, double bestTarget) {
+                                              string group, double bestTarget, double maxEffort) {
       var values = row.Values;
       if (!hits.ContainsKey(group)) {
@@ -444 +464 @@
         var target = (problem.IsMaximization() ? (1 - targets[i]) : (1 + targets[i])) * bestTarget;
         var current = values[j];
+        if (current.Item1 > maxEffort) break;
         if (problem.IsMaximization() && current.Item2 >= target
           || !problem.IsMaximization() && current.Item2 <= target) {
@@ -454 +475 @@
       }
       if (j == values.Count) j--;
+      var effort = Math.Min(values[j].Item1, maxEffort);
       if (i < targets.Length) {
-        if (misses[group].ContainsKey(values[j].Item1))
-          misses[group][values[j].Item1] += targets.Length - i;
-        else misses[group][values[j].Item1] = targets.Length - i;
-      }
-      return values[j].Item1;
+        if (misses[group].ContainsKey(effort))
+          misses[group][effort] += targets.Length - i;
+        else misses[group][effort] = targets.Length - i;
+      }
+      return effort;
     }