Index: trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataRow.cs
===================================================================
--- trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataRow.cs	(revision 14775)
+++ trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataRow.cs	(revision 15048)
@@ -30,5 +30,5 @@
 
 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,4 +105,8 @@
       OnVisualPropertiesChanged();
     }
+    protected override void OnNameChanged() {
+      base.OnNameChanged();
+      VisualProperties.DisplayName = Name;
+    }
   }
 }
Index: trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataTable.cs
===================================================================
--- trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataTable.cs	(revision 14775)
+++ trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataTable.cs	(revision 15048)
@@ -107,5 +107,5 @@
     public event EventHandler VisualPropertiesChanged;
     protected virtual void OnVisualPropertiesChanged() {
-      EventHandler handler = VisualPropertiesChanged;
+      var handler = VisualPropertiesChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }
@@ -115,11 +115,12 @@
     }
 
-    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,5 +130,5 @@
       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,5 +138,5 @@
       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,5 +148,5 @@
       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,32 +160,32 @@
     }
 
-    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();
     }
Index: trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/ExpectedRuntimeHelper.cs
===================================================================
--- trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/ExpectedRuntimeHelper.cs	(revision 14775)
+++ trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/ExpectedRuntimeHelper.cs	(revision 15048)
@@ -46,7 +46,7 @@
 
   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,6 +57,5 @@
 
     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);
     }
   }
Index: trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerClockAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerClockAnalyzer.cs	(revision 14775)
+++ trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerClockAnalyzer.cs	(revision 15048)
@@ -91,6 +91,6 @@
 
       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,6 +98,6 @@
       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);
Index: trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerEvaluationsAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerEvaluationsAnalyzer.cs	(revision 14775)
+++ trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerEvaluationsAnalyzer.cs	(revision 15048)
@@ -88,21 +88,23 @@
       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();
