Changeset 15282 for branches/PerformanceComparison/HeuristicLab.Analysis

Timestamp:

07/24/17 09:51:10 (7 years ago)

Author:

abeham

Message:

#2457: merged trunk into branch

Location:

branches/PerformanceComparison/HeuristicLab.Analysis

Files:

• . (modified) (1 prop)
• 3.3/DataVisualization/DataRowVisualProperties.cs (modified) (7 diffs)
• 3.3/DataVisualization/DataTable.cs (modified) (1 diff)
• 3.3/DataVisualization/DataTableVisualProperties.cs (modified) (6 diffs)
• 3.3/DataVisualization/IndexedDataRow.cs (modified) (2 diffs)
• 3.3/DataVisualization/IndexedDataTable.cs (modified) (6 diffs)
• 3.3/QualityAnalysis/ExpectedRuntimeHelper.cs (modified) (2 diffs)
• 3.3/QualityAnalysis/QualityPerClockAnalyzer.cs (modified) (2 diffs)
• 3.3/QualityAnalysis/QualityPerEvaluationsAnalyzer.cs (modified) (1 diff)

branches/PerformanceComparison/HeuristicLab.Analysis/3.3/DataVisualization/DataRowVisualProperties.cs

@@ -52 +52 @@
     }
     #endregion
-    #region Histogram Aggregation
-    public enum DataRowHistogramAggregation {
-      Overlapping,
-      SideBySide,
-      Stacked
-    }
-    #endregion
 
     private DataRowChartType chartType;
@@ -130 +123 @@
       }
     }
-    private int bins;
-    public int Bins {
-      get { return bins; }
-      set {
-        if (bins != value) {
-          bins = value;
-          OnPropertyChanged("Bins");
-        }
-      }
-    }
-    private bool exactBins;
-    public bool ExactBins {
-      get { return exactBins; }
-      set {
-        if (exactBins != value) {
-          exactBins = value;
-          OnPropertyChanged("ExactBins");
-        }
-      }
-    }
-    private DataRowHistogramAggregation aggregation;
-    public DataRowHistogramAggregation Aggregation {
-      get { return aggregation; }
-      set {
-        if (aggregation != value) {
-          aggregation = value;
-          OnPropertyChanged("Aggregation");
-        }
-      }
-    }
+
     private double scaleFactor;
     public double ScaleFactor {
@@ -232 +196 @@
       set { lineWidth = value; }
     }
-    [Storable(Name = "Bins")]
-    private int StorableBins {
-      get { return bins; }
-      set { bins = value; }
-    }
-    [Storable(Name = "ExactBins")]
-    private bool StorableExactBins {
-      get { return exactBins; }
-      set { exactBins = value; }
-    }
-    [Storable(Name = "Aggregation", DefaultValue = DataRowHistogramAggregation.Overlapping)]
-    private DataRowHistogramAggregation StorableAggregation {
-      get { return aggregation; }
-      set { aggregation = value; }
-    }
     [Storable(Name = "ScaleFactor")]
     private double StorableScaleFactor {
@@ -262 +211 @@
       set { displayName = value; }
     }
+    #endregion
+
+    #region Histogram Properties - Backwards Compatability
+    internal enum DataRowHistogramAggregation {
+      Overlapping,
+      SideBySide,
+      Stacked
+    }
+
+    internal int? Bins { get; private set; }
+    internal bool? ExactBins { get; private set; }
+    internal DataRowHistogramAggregation? Aggregation { get; private set; }
+
+    [Storable(Name = "Bins", AllowOneWay = true)]
+    private int StorableBins { set { Bins = value; } }
+    [Storable(Name = "ExactBins", AllowOneWay = true)]
+    private bool StorableExactBins { set { ExactBins = value; } }
+    [Storable(Name = "Aggregation", AllowOneWay = true)]
+    private DataRowHistogramAggregation StorableAggregation { set { Aggregation = value; } }
     #endregion
 
@@ -275 +243 @@
       this.startIndexZero = original.startIndexZero;
       this.lineWidth = original.lineWidth;
-      this.bins = original.bins;
-      this.exactBins = original.exactBins;
-      this.aggregation = original.aggregation;
       this.scaleFactor = original.scaleFactor;
       this.displayName = original.displayName;
@@ -290 +255 @@
       startIndexZero = false;
       lineWidth = 1;
-      bins = 10;
-      exactBins = false;
-      aggregation = DataRowHistogramAggregation.Overlapping;
       scaleFactor = 1.0;
       displayName = String.Empty;
@@ -318 +280 @@
       if (secondXAxis == default(bool)
         && lineStyle == default(DataRowLineStyle)
-        && lineWidth == default(int) && bins == default(int) && exactBins == default(bool)
         && displayName == default(string)) {
         secondXAxis = false;
         lineStyle = DataRowLineStyle.Solid;
         lineWidth = 1;
-        bins = 10;
-        exactBins = false;
         displayName = String.Empty;
       }

branches/PerformanceComparison/HeuristicLab.Analysis/3.3/DataVisualization/DataTable.cs

@@ -112 +112 @@
       if (VisualProperties == null) VisualProperties = new DataTableVisualProperties(name);
       if (VisualProperties.Title == null) VisualProperties.Title = name;
+
+      #region Backwards Compatability Histogram Visual Properties 
+      var rowProperties = Rows.Select(r => r.VisualProperties).ToList();
+      if (rowProperties.Any(r => r.Bins.HasValue))
+        VisualProperties.HistogramBins = rowProperties.Where(r => r.Bins.HasValue).Max(r => r.Bins.Value);
+      if (rowProperties.Any(r => r.ExactBins.HasValue))
+        VisualProperties.HistogramExactBins = rowProperties.Where(r => r.ExactBins.HasValue).Any(r => r.ExactBins.Value);
+      if (rowProperties.Any(r => r.Aggregation.HasValue)) {
+        var maxOccurrence = rowProperties
+          .Where(r => r.Aggregation.HasValue).Select(r => r.Aggregation.Value)
+          .GroupBy(x => x).OrderByDescending(x => x.Count())
+          .First().Key;
+        VisualProperties.HistogramAggregation = (DataTableVisualProperties.DataTableHistogramAggregation)maxOccurrence;
+      }
+      #endregion
     }
     #endregion

branches/PerformanceComparison/HeuristicLab.Analysis/3.3/DataVisualization/DataTableVisualProperties.cs

@@ -20 +20 @@
 #endregion
 
+using System;
+using System.ComponentModel;
+using System.Drawing;
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System.ComponentModel;
-using System.Drawing;
 
 namespace HeuristicLab.Analysis {
@@ -31 +32 @@
   [StorableClass]
   public class DataTableVisualProperties : DeepCloneable, INotifyPropertyChanged {
+
+    #region Histogram Aggregation
+    public enum DataTableHistogramAggregation {
+      Overlapping,
+      SideBySide,
+      Stacked
+    }
+    #endregion
+
     private Font titleFont;
     public Font TitleFont {
@@ -352 +362 @@
         secondYAxisLogScale = value;
         OnPropertyChanged("SecondYAxisLogScale");
+      }
+    }
+
+    private int histogramBins;
+    public int HistogramBins {
+      get { return histogramBins; }
+      set {
+        if (histogramBins != value) {
+          histogramBins = value;
+          OnPropertyChanged("HistogramBins");
+        }
+      }
+    }
+
+    private bool histogramExactBins;
+    public bool HistogramExactBins {
+      get { return histogramExactBins; }
+      set {
+        if (histogramExactBins != value) {
+          histogramExactBins = value;
+          OnPropertyChanged("HistogramExactBins");
+        }
+      }
+    }
+
+    private DataTableHistogramAggregation histogramAggregation;
+    public DataTableHistogramAggregation HistogramAggregation {
+      get { return histogramAggregation; }
+      set {
+        if (histogramAggregation != value) {
+          histogramAggregation = value;
+          OnPropertyChanged("HistogramAggregation");
+        }
       }
     }
@@ -500 +543 @@
       get { return secondYAxisLogScale; }
       set { secondYAxisLogScale = value; }
+    }
+    [Storable(Name = "HistogramBins", DefaultValue = 10)]
+    private int StorableHistogramBins {
+      get { return histogramBins; }
+      set { histogramBins = value; }
+    }
+    [Storable(Name = "HistogramExactBins", DefaultValue = false)]
+    private bool StorableHistogramExactBins {
+      get { return histogramExactBins; }
+      set { histogramExactBins = value; }
+    }
+    [Storable(Name = "HistogramAggregation", DefaultValue = DataTableHistogramAggregation.Overlapping)]
+    private DataTableHistogramAggregation StorableHistogramAggregation {
+      get { return histogramAggregation; }
+      set { histogramAggregation = value; }
     }
     #endregion
@@ -536 +594 @@
       this.yAxisLogScale = original.yAxisLogScale;
       this.secondYAxisLogScale = original.secondYAxisLogScale;
+      this.histogramBins = original.histogramBins;
+      this.histogramExactBins = original.histogramExactBins;
+      this.histogramAggregation = original.histogramAggregation;
     }
     public DataTableVisualProperties() {
@@ -565 +626 @@
       this.yAxisLogScale = false;
       this.secondYAxisLogScale = false;
+      histogramBins = 10;
+      histogramExactBins = false;
+      histogramAggregation = DataTableHistogramAggregation.Overlapping;
     }
     public DataTableVisualProperties(string title)

branches/PerformanceComparison/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataRow.cs

@@ -30 +30 @@
 
 namespace HeuristicLab.Analysis {
-  [Item("IndexedDataRow", "A data row that contains time series.")]
+  [Item("IndexedDataRow", "A data row that contains a series of points.")]
   [StorableClass]
   public class IndexedDataRow<T> : NamedItem {
@@ -105 +105 @@
       OnVisualPropertiesChanged();
     }
+    protected override void OnNameChanged() {
+      base.OnNameChanged();
+      VisualProperties.DisplayName = Name;
+    }
   }
 }

branches/PerformanceComparison/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataTable.cs

@@ -107 +107 @@
     public event EventHandler VisualPropertiesChanged;
     protected virtual void OnVisualPropertiesChanged() {
-      EventHandler handler = VisualPropertiesChanged;
+      var handler = VisualPropertiesChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }
@@ -115 +115 @@
     }
 
-    protected virtual void RegisterRowsEvents() {
-      rows.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(rows_ItemsAdded);
-      rows.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(rows_ItemsRemoved);
-      rows.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(rows_ItemsReplaced);
-      rows.CollectionReset += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(rows_CollectionReset);
-    }
-    private void rows_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+    private void RegisterRowsEvents() {
+      rows.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(RowsOnItemsAdded);
+      rows.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(RowsOnItemsRemoved);
+      rows.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(RowsOnItemsReplaced);
+      rows.CollectionReset += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(RowsOnCollectionReset);
+      foreach (var row in Rows) RegisterRowEvents(row);
+    }
+    protected virtual void RowsOnItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
       foreach (var row in e.Items)
         this.RegisterRowEvents(row);
@@ -129 +130 @@
       this.OnReset();
     }
-    private void rows_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+    protected virtual void RowsOnItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
       foreach (var row in e.Items)
         this.DeregisterRowEvents(row);
@@ -137 +138 @@
       this.OnReset();
     }
-    private void rows_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+    protected virtual void RowsOnItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
       foreach (var row in e.OldItems)
         this.DeregisterRowEvents(row);
@@ -147 +148 @@
       this.OnReset();
     }
-    private void rows_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+    protected virtual void RowsOnCollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
       foreach (var row in e.OldItems)
         this.DeregisterRowEvents(row);
@@ -159 +160 @@
     }
 
-    protected virtual void RegisterRowEvents(IndexedDataRow<T> row) {
-      row.Values.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsAdded);
-      row.Values.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsMoved);
-      row.Values.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsRemoved);
-      row.Values.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsReplaced);
-      row.Values.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_CollectionReset);
-    }
-    protected virtual void DeregisterRowEvents(IndexedDataRow<T> row) {
-      row.Values.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsAdded);
-      row.Values.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsMoved);
-      row.Values.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsRemoved);
-      row.Values.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsReplaced);
-      row.Values.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_CollectionReset);
-    }
-
-    private void Values_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
-      this.OnReset();
-    }
-    private void Values_ItemsMoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
-      this.OnReset();
-    }
-    private void Values_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
-      this.OnReset();
-    }
-    private void Values_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
-      this.OnReset();
-    }
-    private void Values_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+    private void RegisterRowEvents(IndexedDataRow<T> row) {
+      row.Values.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnItemsAdded);
+      row.Values.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnItemsMoved);
+      row.Values.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnItemsRemoved);
+      row.Values.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnItemsReplaced);
+      row.Values.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnCollectionReset);
+    }
+    private void DeregisterRowEvents(IndexedDataRow<T> row) {
+      row.Values.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnItemsAdded);
+      row.Values.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnItemsMoved);
+      row.Values.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnItemsRemoved);
+      row.Values.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnItemsReplaced);
+      row.Values.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(ValuesOnCollectionReset);
+    }
+
+    protected virtual void ValuesOnItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+      this.OnReset();
+    }
+    protected virtual void ValuesOnItemsMoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+      this.OnReset();
+    }
+    protected virtual void ValuesOnItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+      this.OnReset();
+    }
+    protected virtual void ValuesOnItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+      this.OnReset();
+    }
+    protected virtual void ValuesOnCollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
       this.OnReset();
     }

branches/PerformanceComparison/HeuristicLab.Analysis/3.3/QualityAnalysis/ExpectedRuntimeHelper.cs

@@ -46 +46 @@
 
   public struct ErtCalculationResult {
-    public int SuccessfulRuns;
-    public int TotalRuns;
-    public double ExpectedRuntime;
+    public readonly int SuccessfulRuns;
+    public readonly int TotalRuns;
+    public readonly double ExpectedRuntime;
 
     public ErtCalculationResult(int successful, int total, double ert) {
@@ -57 +57 @@
 
     public override string ToString() {
-      return SuccessfulRuns == 0 ? "\u221e" // infinity symbol
-                                 : ExpectedRuntime.ToString("##,0.0", CultureInfo.CurrentCulture.NumberFormat);
+      return ExpectedRuntime.ToString("##,0.0", CultureInfo.CurrentCulture.NumberFormat);
     }
   }

branches/PerformanceComparison/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerClockAnalyzer.cs

@@ -91 +91 @@
 
       if (values.Count == 0) {
-        values.Add(newEntry);
-        values.Add(Tuple.Create(runtimeSoFar, bestQuality)); // duplicate entry that will be replaced
+        values.Add(newEntry); // record the first data
+        values.Add(Tuple.Create(runtimeSoFar, bestQuality)); // last entry records max number of evaluations
         return base.Apply();
       }
@@ -98 +98 @@
       var improvement = values.Last().Item2 != bestQuality;
       if (improvement) {
-        values[values.Count - 1] = newEntry;
-        values.Add(Tuple.Create(runtimeSoFar, bestQuality)); // duplicate entry that will be replaced
+        values[values.Count - 1] = newEntry; // record the improvement
+        values.Add(Tuple.Create(runtimeSoFar, bestQuality)); // last entry records max number of evaluations
       } else {
         values[values.Count - 1] = Tuple.Create(runtimeSoFar, bestQuality);

branches/PerformanceComparison/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerEvaluationsAnalyzer.cs

@@ -88 +88 @@
       if (evalMoves != null) evaluations += evalMoves.Value * MoveCostPerSolutionParameter.ActualValue.Value;
 
-      var dataTable = QualityPerEvaluationsParameter.ActualValue;
-      var values = dataTable.Rows["First-hit Graph"].Values;
-      if (evaluations == 0 || values.Count > 0 && evaluations < values.Last().Item1) evaluations = 1;
-      var newEntry = Tuple.Create(evaluations, bestQuality);
+      if (evaluations > 0) {
+        var dataTable = QualityPerEvaluationsParameter.ActualValue;
+        var values = dataTable.Rows["First-hit Graph"].Values;
 
-      if (values.Count == 0) {
-        values.Add(newEntry);
-        values.Add(Tuple.Create(evaluations, bestQuality)); // duplicate entry that will be replaced
-        return base.Apply();
-      }
+        var newEntry = Tuple.Create(evaluations, bestQuality);
 
-      var improvement = values.Last().Item2 != bestQuality;
-      if (improvement) {
-        values[values.Count - 1] = newEntry;
-        values.Add(Tuple.Create(evaluations, bestQuality)); // duplicate entry that will be replaced
-      } else {
-        values[values.Count - 1] = Tuple.Create(evaluations, bestQuality);
+        if (values.Count == 0) {
+          values.Add(newEntry); // record the first data
+          values.Add(Tuple.Create(evaluations, bestQuality)); // last entry records max number of evaluations
+          return base.Apply();
+        }
+
+        var improvement = values.Last().Item2 != bestQuality;
+        if (improvement) {
+          values[values.Count - 1] = newEntry; // record the improvement
+          values.Add(Tuple.Create(evaluations, bestQuality)); // last entry records max number of evaluations
+        } else {
+          values[values.Count - 1] = Tuple.Create(evaluations, bestQuality); // the last entry is updated
+        }
       }
       return base.Apply();