Index: /trunk/sources/HeuristicLab.Analysis.Views/3.3/HeuristicLab.Analysis.Views-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Analysis.Views/3.3/HeuristicLab.Analysis.Views-3.3.csproj	(revision 14101)
+++ /trunk/sources/HeuristicLab.Analysis.Views/3.3/HeuristicLab.Analysis.Views-3.3.csproj	(revision 14102)
@@ -122,4 +122,8 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="IndexedDataTableView.cs" />
+    <Compile Include="IndexedDataTableView.Designer.cs">
+      <DependentUpon>IndexedDataTableView.cs</DependentUpon>
+    </Compile>
     <Compile Include="ScatterPlotVisualPropertiesDialog.cs">
       <SubType>Form</SubType>
Index: /trunk/sources/HeuristicLab.Analysis.Views/3.3/IndexedDataTableView.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis.Views/3.3/IndexedDataTableView.Designer.cs	(revision 14102)
+++ /trunk/sources/HeuristicLab.Analysis.Views/3.3/IndexedDataTableView.Designer.cs	(revision 14102)
@@ -0,0 +1,125 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace HeuristicLab.Analysis.Views {
+  partial class IndexedDataTableView<T> {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing) {
+        if (components != null) components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea1 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
+      System.Windows.Forms.DataVisualization.Charting.Legend legend1 = new System.Windows.Forms.DataVisualization.Charting.Legend();
+      System.Windows.Forms.DataVisualization.Charting.Series series1 = new System.Windows.Forms.DataVisualization.Charting.Series();
+      System.Windows.Forms.DataVisualization.Charting.Title title1 = new System.Windows.Forms.DataVisualization.Charting.Title();
+      this.chart = new HeuristicLab.Visualization.ChartControlsExtensions.EnhancedChart();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      ((System.ComponentModel.ISupportInitialize)(this.chart)).BeginInit();
+      this.SuspendLayout();
+      // 
+      // nameTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
+      this.nameTextBox.Location = new System.Drawing.Point(55, 0);
+      this.nameTextBox.Size = new System.Drawing.Size(279, 20);
+      // 
+      // infoLabel
+      // 
+      this.infoLabel.Location = new System.Drawing.Point(340, 3);
+      // 
+      // chart
+      // 
+      this.chart.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.chart.BorderlineColor = System.Drawing.Color.Black;
+      this.chart.BorderlineDashStyle = System.Windows.Forms.DataVisualization.Charting.ChartDashStyle.Solid;
+      chartArea1.AxisX.Minimum = 0D;
+      chartArea1.CursorX.IsUserEnabled = true;
+      chartArea1.CursorX.IsUserSelectionEnabled = true;
+      chartArea1.CursorY.IsUserEnabled = true;
+      chartArea1.CursorY.IsUserSelectionEnabled = true;
+      chartArea1.Name = "Default";
+      this.chart.ChartAreas.Add(chartArea1);
+      legend1.Alignment = System.Drawing.StringAlignment.Center;
+      legend1.Docking = System.Windows.Forms.DataVisualization.Charting.Docking.Top;
+      legend1.Name = "Default";
+      this.chart.Legends.Add(legend1);
+      this.chart.Location = new System.Drawing.Point(0, 26);
+      this.chart.Name = "chart";
+      series1.ChartArea = "Default";
+      series1.Legend = "Default";
+      series1.Name = "Default";
+      this.chart.Series.Add(series1);
+      this.chart.Size = new System.Drawing.Size(359, 248);
+      this.chart.TabIndex = 3;
+      this.chart.Text = "chart";
+      title1.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+      title1.Name = "Default";
+      title1.Text = "Title";
+      this.chart.Titles.Add(title1);
+      this.chart.CustomizeLegend += new System.EventHandler<System.Windows.Forms.DataVisualization.Charting.CustomizeLegendEventArgs>(this.chart_CustomizeLegend);
+      this.chart.MouseDown += new System.Windows.Forms.MouseEventHandler(this.chart_MouseDown);
+      this.chart.MouseMove += new System.Windows.Forms.MouseEventHandler(this.chart_MouseMove);
+      // 
+      // DataTableView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.chart);
+      this.Name = "DataTableView";
+      this.Size = new System.Drawing.Size(359, 274);
+      this.Controls.SetChildIndex(this.infoLabel, 0);
+      this.Controls.SetChildIndex(this.chart, 0);
+      this.Controls.SetChildIndex(this.nameLabel, 0);
+      this.Controls.SetChildIndex(this.nameTextBox, 0);
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      ((System.ComponentModel.ISupportInitialize)(this.chart)).EndInit();
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    protected HeuristicLab.Visualization.ChartControlsExtensions.EnhancedChart chart;
+
+  }
+}
Index: /trunk/sources/HeuristicLab.Analysis.Views/3.3/IndexedDataTableView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis.Views/3.3/IndexedDataTableView.cs	(revision 14102)
+++ /trunk/sources/HeuristicLab.Analysis.Views/3.3/IndexedDataTableView.cs	(revision 14102)
@@ -0,0 +1,610 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Collections;
+using HeuristicLab.Core.Views;
+using HeuristicLab.MainForm;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Windows.Forms;
+using System.Windows.Forms.DataVisualization.Charting;
+
+namespace HeuristicLab.Analysis.Views {
+  [View("IndexedDataTable View")]
+  [Content(typeof(IndexedDataTable<>), true)]
+  public partial class IndexedDataTableView<T> : NamedItemView {
+    protected List<Series> invisibleSeries;
+    protected Dictionary<IObservableList<Tuple<T, double>>, IndexedDataRow<T>> valuesRowsTable;
+
+    public new IndexedDataTable<T> Content {
+      get { return (IndexedDataTable<T>)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public IndexedDataTableView() {
+      InitializeComponent();
+      valuesRowsTable = new Dictionary<IObservableList<Tuple<T, double>>, IndexedDataRow<T>>();
+      invisibleSeries = new List<Series>();
+      chart.CustomizeAllChartAreas();
+      chart.ChartAreas[0].CursorX.Interval = 1;
+      chart.SuppressExceptions = true;
+    }
+
+    #region Event Handler Registration
+    protected override void DeregisterContentEvents() {
+      foreach (var row in Content.Rows)
+        DeregisterDataRowEvents(row);
+      Content.VisualPropertiesChanged -= new EventHandler(Content_VisualPropertiesChanged);
+      Content.Rows.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_ItemsAdded);
+      Content.Rows.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_ItemsRemoved);
+      Content.Rows.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_ItemsReplaced);
+      Content.Rows.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_CollectionReset);
+      base.DeregisterContentEvents();
+    }
+
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.VisualPropertiesChanged += new EventHandler(Content_VisualPropertiesChanged);
+      Content.Rows.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_ItemsAdded);
+      Content.Rows.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_ItemsRemoved);
+      Content.Rows.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_ItemsReplaced);
+      Content.Rows.CollectionReset += new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_CollectionReset);
+      foreach (var row in Content.Rows)
+        RegisterDataRowEvents(row);
+    }
+
+    /// <summary>
+    /// Automatically called for every existing data row and whenever a data row is added
+    /// to the data table. Do not call this method directly.
+    /// </summary>
+    /// <param name="row">The DataRow that was added.</param>
+    protected virtual void RegisterDataRowEvents(IndexedDataRow<T> row) {
+      row.NameChanged += new EventHandler(Row_NameChanged);
+      row.VisualPropertiesChanged += new EventHandler(Row_VisualPropertiesChanged);
+      valuesRowsTable.Add(row.Values, row);
+      row.Values.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsAdded);
+      row.Values.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsRemoved);
+      row.Values.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsReplaced);
+      row.Values.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsMoved);
+      row.Values.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_CollectionReset);
+    }
+
+    /// <summary>
+    /// Automatically called for every data row that is removed from the DataTable. Do
+    /// not directly call this method.
+    /// </summary>
+    /// <param name="row">The DataRow that was removed.</param>
+    protected virtual void DeregisterDataRowEvents(IndexedDataRow<T> row) {
+      row.Values.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsAdded);
+      row.Values.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsRemoved);
+      row.Values.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsReplaced);
+      row.Values.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsMoved);
+      row.Values.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_CollectionReset);
+      valuesRowsTable.Remove(row.Values);
+      row.VisualPropertiesChanged -= new EventHandler(Row_VisualPropertiesChanged);
+      row.NameChanged -= new EventHandler(Row_NameChanged);
+    }
+    #endregion
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      invisibleSeries.Clear();
+      chart.Titles[0].Text = string.Empty;
+      chart.ChartAreas[0].AxisX.Title = string.Empty;
+      chart.ChartAreas[0].AxisY.Title = string.Empty;
+      chart.ChartAreas[0].AxisY2.Title = string.Empty;
+      chart.ChartAreas[0].AxisX.IsLogarithmic = false;
+      chart.ChartAreas[0].AxisX2.IsLogarithmic = false;
+      chart.ChartAreas[0].AxisY.IsLogarithmic = false;
+      chart.ChartAreas[0].AxisY2.IsLogarithmic = false;
+      chart.Series.Clear();
+      if (Content != null) {
+        chart.Titles[0].Text = Content.Name;
+        foreach (var row in Content.Rows)
+          AddDataRow(row);
+        ConfigureChartArea(chart.ChartAreas[0]);
+        RecalculateAxesScale(chart.ChartAreas[0]);
+      }
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      chart.Enabled = Content != null;
+    }
+
+    /// <summary>
+    /// Add the DataRow as a series to the chart.
+    /// </summary>
+    /// <param name="row">DataRow to add as series to the chart.</param>
+    protected virtual void AddDataRow(IndexedDataRow<T> row) {
+      if (row.Values.Count == 0) return;
+
+      Series series = new Series(row.Name);
+      if (row.VisualProperties.DisplayName.Trim() != String.Empty) series.LegendText = row.VisualProperties.DisplayName;
+      else series.LegendText = row.Name;
+      ConfigureSeries(series, row);
+      FillSeriesWithRowValues(series, row);
+
+      chart.Series.Add(series);
+      ConfigureChartArea(chart.ChartAreas[0]);
+      RecalculateAxesScale(chart.ChartAreas[0]);
+      UpdateYCursorInterval();
+    }
+
+    private void ConfigureSeries(Series series, IndexedDataRow<T> row) {
+      RemoveCustomPropertyIfExists(series, "PointWidth");
+      series.BorderWidth = 1;
+      series.BorderDashStyle = ChartDashStyle.Solid;
+      series.BorderColor = Color.Empty;
+
+      if (row.VisualProperties.Color != Color.Empty)
+        series.Color = row.VisualProperties.Color;
+      else series.Color = Color.Empty;
+      series.IsVisibleInLegend = row.VisualProperties.IsVisibleInLegend;
+
+      series.SmartLabelStyle.Enabled = true;
+      series.SmartLabelStyle.AllowOutsidePlotArea = LabelOutsidePlotAreaStyle.No;
+      series.SmartLabelStyle.CalloutLineAnchorCapStyle = LineAnchorCapStyle.None;
+      series.SmartLabelStyle.CalloutLineColor = series.Color;
+      series.SmartLabelStyle.CalloutLineWidth = 2;
+      series.SmartLabelStyle.CalloutStyle = LabelCalloutStyle.Underlined;
+      series.SmartLabelStyle.IsOverlappedHidden = false;
+      series.SmartLabelStyle.MaxMovingDistance = 200;
+
+      switch (row.VisualProperties.ChartType) {
+        case DataRowVisualProperties.DataRowChartType.Line:
+          series.ChartType = SeriesChartType.FastLine;
+          series.BorderWidth = row.VisualProperties.LineWidth;
+          series.BorderDashStyle = ConvertLineStyle(row.VisualProperties.LineStyle);
+          break;
+        case DataRowVisualProperties.DataRowChartType.Bars:
+          // Bar is incompatible with anything but Bar and StackedBar*
+          if (!chart.Series.Any(x => x.ChartType != SeriesChartType.Bar && x.ChartType != SeriesChartType.StackedBar && x.ChartType != SeriesChartType.StackedBar100)) {
+            series.ChartType = SeriesChartType.Bar;
+            chart.ChartAreas[0].AxisX.Interval = 1;
+          } else {
+            series.ChartType = SeriesChartType.FastPoint; //default
+            row.VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Points;
+          }
+          break;
+        case DataRowVisualProperties.DataRowChartType.Columns:
+          series.ChartType = SeriesChartType.Column;
+          break;
+        case DataRowVisualProperties.DataRowChartType.Points:
+          series.ChartType = SeriesChartType.FastPoint;
+          break;
+        case DataRowVisualProperties.DataRowChartType.StepLine:
+          series.ChartType = SeriesChartType.StepLine;
+          series.BorderWidth = row.VisualProperties.LineWidth;
+          series.BorderDashStyle = ConvertLineStyle(row.VisualProperties.LineStyle);
+          break;
+        default:
+          series.ChartType = SeriesChartType.FastPoint;
+          break;
+      }
+      series.YAxisType = row.VisualProperties.SecondYAxis ? AxisType.Secondary : AxisType.Primary;
+      series.XAxisType = row.VisualProperties.SecondXAxis ? AxisType.Secondary : AxisType.Primary;
+      if (row.VisualProperties.DisplayName.Trim() != String.Empty) series.LegendText = row.VisualProperties.DisplayName;
+      else series.LegendText = row.Name;
+      series.ToolTip = series.LegendText + " X = #VALX, Y = #VALY";
+    }
+
+    private void ConfigureChartArea(ChartArea area) {
+      if (Content.VisualProperties.TitleFont != null) chart.Titles[0].Font = Content.VisualProperties.TitleFont;
+      if (!Content.VisualProperties.TitleColor.IsEmpty) chart.Titles[0].ForeColor = Content.VisualProperties.TitleColor;
+
+      if (Content.VisualProperties.AxisTitleFont != null) area.AxisX.TitleFont = Content.VisualProperties.AxisTitleFont;
+      if (!Content.VisualProperties.AxisTitleColor.IsEmpty) area.AxisX.TitleForeColor = Content.VisualProperties.AxisTitleColor;
+      area.AxisX.Title = Content.VisualProperties.XAxisTitle;
+
+      if (Content.VisualProperties.AxisTitleFont != null) area.AxisX2.TitleFont = Content.VisualProperties.AxisTitleFont;
+      if (!Content.VisualProperties.AxisTitleColor.IsEmpty) area.AxisX2.TitleForeColor = Content.VisualProperties.AxisTitleColor;
+      area.AxisX2.Title = Content.VisualProperties.SecondXAxisTitle;
+
+      if (Content.VisualProperties.AxisTitleFont != null) area.AxisY.TitleFont = Content.VisualProperties.AxisTitleFont;
+      if (!Content.VisualProperties.AxisTitleColor.IsEmpty) area.AxisY.TitleForeColor = Content.VisualProperties.AxisTitleColor;
+      area.AxisY.Title = Content.VisualProperties.YAxisTitle;
+
+      if (Content.VisualProperties.AxisTitleFont != null) area.AxisY2.TitleFont = Content.VisualProperties.AxisTitleFont;
+      if (!Content.VisualProperties.AxisTitleColor.IsEmpty) area.AxisY2.TitleForeColor = Content.VisualProperties.AxisTitleColor;
+      area.AxisY2.Title = Content.VisualProperties.SecondYAxisTitle;
+
+      if (typeof(T).Equals(typeof(DateTime))) {
+        area.AxisX.IntervalType = DateTimeIntervalType.Hours;
+        area.AxisX.LabelStyle.Format = "dd.MM.yyyy HH:mm";
+        area.AxisX.IntervalAutoMode = IntervalAutoMode.VariableCount;
+      }
+    }
+
+    private void RecalculateAxesScale(ChartArea area) {
+      // Reset the axes bounds so that RecalculateAxesScale() will assign new bounds
+      foreach (Axis a in area.Axes) {
+        a.Minimum = double.NaN;
+        a.Maximum = double.NaN;
+      }
+
+      if (chart.Series.Any(x => x.Enabled && x.XAxisType == AxisType.Primary && (x.Points.Count == 0 || x.Points.Any(y => y.XValue <= 0))))
+        area.AxisX.IsLogarithmic = false;
+      else area.AxisX.IsLogarithmic = Content.VisualProperties.XAxisLogScale;
+      if (chart.Series.Any(x => x.Enabled && x.XAxisType == AxisType.Secondary && (x.Points.Count == 0 || x.Points.Any(y => y.XValue <= 0))))
+        area.AxisX2.IsLogarithmic = false;
+      else area.AxisX2.IsLogarithmic = Content.VisualProperties.SecondXAxisLogScale;
+
+      if (chart.Series.Any(x => x.Enabled && x.YAxisType == AxisType.Primary && (x.Points.Count == 0 || x.Points.Any(y => y.YValues.Min() <= 0))))
+        area.AxisY.IsLogarithmic = false;
+      else area.AxisY.IsLogarithmic = Content.VisualProperties.YAxisLogScale;
+      if (chart.Series.Any(x => x.Enabled && x.YAxisType == AxisType.Secondary && (x.Points.Count == 0 || x.Points.Any(y => y.YValues.Min() <= 0))))
+        area.AxisY2.IsLogarithmic = false;
+      else area.AxisY2.IsLogarithmic = Content.VisualProperties.SecondYAxisLogScale;
+
+      area.RecalculateAxesScale();
+      area.AxisX.IsMarginVisible = false;
+      area.AxisX2.IsMarginVisible = false;
+
+      area.AxisX.IsStartedFromZero = Content.Rows.Where(x => !x.VisualProperties.SecondXAxis).Any(x => x.VisualProperties.StartIndexZero);
+      area.AxisX2.IsStartedFromZero = Content.Rows.Where(x => x.VisualProperties.SecondXAxis).Any(x => x.VisualProperties.StartIndexZero);
+
+      if (!Content.VisualProperties.XAxisMinimumAuto && !double.IsNaN(Content.VisualProperties.XAxisMinimumFixedValue)) area.AxisX.Minimum = Content.VisualProperties.XAxisMinimumFixedValue;
+      if (!Content.VisualProperties.XAxisMaximumAuto && !double.IsNaN(Content.VisualProperties.XAxisMaximumFixedValue)) area.AxisX.Maximum = Content.VisualProperties.XAxisMaximumFixedValue;
+      if (!Content.VisualProperties.SecondXAxisMinimumAuto && !double.IsNaN(Content.VisualProperties.SecondXAxisMinimumFixedValue)) area.AxisX2.Minimum = Content.VisualProperties.SecondXAxisMinimumFixedValue;
+      if (!Content.VisualProperties.SecondXAxisMaximumAuto && !double.IsNaN(Content.VisualProperties.SecondXAxisMaximumFixedValue)) area.AxisX2.Maximum = Content.VisualProperties.SecondXAxisMaximumFixedValue;
+      if (!Content.VisualProperties.YAxisMinimumAuto && !double.IsNaN(Content.VisualProperties.YAxisMinimumFixedValue)) area.AxisY.Minimum = Content.VisualProperties.YAxisMinimumFixedValue;
+      if (!Content.VisualProperties.YAxisMaximumAuto && !double.IsNaN(Content.VisualProperties.YAxisMaximumFixedValue)) area.AxisY.Maximum = Content.VisualProperties.YAxisMaximumFixedValue;
+      if (!Content.VisualProperties.SecondYAxisMinimumAuto && !double.IsNaN(Content.VisualProperties.SecondYAxisMinimumFixedValue)) area.AxisY2.Minimum = Content.VisualProperties.SecondYAxisMinimumFixedValue;
+      if (!Content.VisualProperties.SecondYAxisMaximumAuto && !double.IsNaN(Content.VisualProperties.SecondYAxisMaximumFixedValue)) area.AxisY2.Maximum = Content.VisualProperties.SecondYAxisMaximumFixedValue;
+      if (area.AxisX.Minimum >= area.AxisX.Maximum) area.AxisX.Maximum = area.AxisX.Minimum + 1;
+      if (area.AxisX2.Minimum >= area.AxisX2.Maximum) area.AxisX2.Maximum = area.AxisX2.Minimum + 1;
+      if (area.AxisY.Minimum >= area.AxisY.Maximum) area.AxisY.Maximum = area.AxisY.Minimum + 1;
+      if (area.AxisY2.Minimum >= area.AxisY2.Maximum) area.AxisY2.Maximum = area.AxisY2.Minimum + 1;
+    }
+
+    /// <summary>
+    /// Set the Y Cursor interval to visible points of enabled series.
+    /// </summary>
+    protected virtual void UpdateYCursorInterval() {
+      double interestingValuesRange = (
+        from series in chart.Series
+        where series.Enabled
+        let values = (from point in series.Points
+                      where !point.IsEmpty
+                      select point.YValues[0]).DefaultIfEmpty(1.0)
+        let range = values.Max() - values.Min()
+        where range > 0.0
+        select range
+        ).DefaultIfEmpty(1.0).Min();
+
+      double digits = (int)Math.Log10(interestingValuesRange) - 3;
+      double yZoomInterval = Math.Pow(10, digits);
+      this.chart.ChartAreas[0].CursorY.Interval = yZoomInterval;
+    }
+
+
+    /// <summary>
+    /// Remove the corresponding series for a certain DataRow.
+    /// </summary>
+    /// <param name="row">DataRow which series should be removed.</param>
+    protected virtual void RemoveDataRow(IndexedDataRow<T> row) {
+      if (chart.Series.All(x => x.Name != row.Name)) return;
+      Series series = chart.Series[row.Name];
+      chart.Series.Remove(series);
+      if (invisibleSeries.Contains(series))
+        invisibleSeries.Remove(series);
+      RecalculateAxesScale(chart.ChartAreas[0]);
+    }
+
+    #region Event Handlers
+    #region Content Event Handlers
+    protected override void Content_NameChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_NameChanged), sender, e);
+      else {
+        chart.Titles[0].Text = Content.Name;
+        base.Content_NameChanged(sender, e);
+      }
+    }
+    private void Content_VisualPropertiesChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_VisualPropertiesChanged), sender, e);
+      else {
+        ConfigureChartArea(chart.ChartAreas[0]);
+        RecalculateAxesScale(chart.ChartAreas[0]); // axes min/max could have changed
+      }
+    }
+    #endregion
+    #region Rows Event Handlers
+    private void Rows_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+      if (InvokeRequired)
+        Invoke(new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_ItemsAdded), sender, e);
+      else {
+        foreach (var row in e.Items) {
+          AddDataRow(row);
+          RegisterDataRowEvents(row);
+        }
+      }
+    }
+    private void Rows_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+      if (InvokeRequired)
+        Invoke(new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_ItemsRemoved), sender, e);
+      else {
+        foreach (var row in e.Items) {
+          DeregisterDataRowEvents(row);
+          RemoveDataRow(row);
+        }
+      }
+    }
+    private void Rows_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+      if (InvokeRequired)
+        Invoke(new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_ItemsReplaced), sender, e);
+      else {
+        foreach (var row in e.OldItems) {
+          DeregisterDataRowEvents(row);
+          RemoveDataRow(row);
+        }
+        foreach (var row in e.Items) {
+          AddDataRow(row);
+          RegisterDataRowEvents(row);
+        }
+      }
+    }
+    private void Rows_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+      if (InvokeRequired)
+        Invoke(new CollectionItemsChangedEventHandler<IndexedDataRow<T>>(Rows_CollectionReset), sender, e);
+      else {
+        foreach (var row in e.OldItems) {
+          DeregisterDataRowEvents(row);
+          RemoveDataRow(row);
+        }
+        foreach (var row in e.Items) {
+          AddDataRow(row);
+          RegisterDataRowEvents(row);
+        }
+      }
+    }
+    #endregion
+    #region Row Event Handlers
+    private void Row_VisualPropertiesChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Row_VisualPropertiesChanged), sender, e);
+      else {
+        var row = (IndexedDataRow<T>)sender;
+        Series series = chart.Series[row.Name];
+        series.Points.Clear();
+        ConfigureSeries(series, row);
+        FillSeriesWithRowValues(series, row);
+        RecalculateAxesScale(chart.ChartAreas[0]);
+      }
+    }
+    private void Row_NameChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Row_NameChanged), sender, e);
+      else {
+        var row = (IndexedDataRow<T>)sender;
+        chart.Series[row.Name].Name = row.Name;
+      }
+    }
+    #endregion
+    #region Values Event Handlers
+    private void Values_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+      if (InvokeRequired)
+        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsAdded), sender, e);
+      else {
+        IndexedDataRow<T> row = null;
+        valuesRowsTable.TryGetValue((IObservableList<Tuple<T, double>>)sender, out row);
+        if (row != null) {
+          Series rowSeries = chart.Series[row.Name];
+          if (!invisibleSeries.Contains(rowSeries)) {
+            rowSeries.Points.Clear();
+            FillSeriesWithRowValues(rowSeries, row);
+            RecalculateAxesScale(chart.ChartAreas[0]);
+            UpdateYCursorInterval();
+          }
+        } else AddDataRow((IndexedDataRow<T>)sender);
+      }
+    }
+    private void Values_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+      if (InvokeRequired)
+        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsRemoved), sender, e);
+      else {
+        IndexedDataRow<T> row = null;
+        valuesRowsTable.TryGetValue((IObservableList<Tuple<T, double>>)sender, out row);
+        if (row != null) {
+          if (row.Values.Count == 0) {
+            RemoveDataRow(row);
+          } else {
+            Series rowSeries = chart.Series[row.Name];
+            if (!invisibleSeries.Contains(rowSeries)) {
+              rowSeries.Points.Clear();
+              FillSeriesWithRowValues(rowSeries, row);
+              RecalculateAxesScale(chart.ChartAreas[0]);
+              UpdateYCursorInterval();
+            }
+          }
+        }
+      }
+    }
+    private void Values_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+      if (InvokeRequired)
+        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsReplaced), sender, e);
+      else {
+        IndexedDataRow<T> row = null;
+        valuesRowsTable.TryGetValue((IObservableList<Tuple<T, double>>)sender, out row);
+        if (row != null) {
+          if (row.Values.Count == 0) {
+            RemoveDataRow(row);
+          } else {
+            Series rowSeries = chart.Series[row.Name];
+            if (!invisibleSeries.Contains(rowSeries)) {
+              if (row.VisualProperties.ChartType == DataRowVisualProperties.DataRowChartType.Histogram) {
+                rowSeries.Points.Clear();
+                FillSeriesWithRowValues(rowSeries, row);
+              } else {
+                foreach (IndexedItem<Tuple<T, double>> item in e.Items) {
+                  rowSeries.Points[item.Index].SetValueXY(item.Value.Item1, item.Value.Item2);
+                }
+              }
+              RecalculateAxesScale(chart.ChartAreas[0]);
+              UpdateYCursorInterval();
+            }
+          }
+        }
+      }
+    }
+    private void Values_ItemsMoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+      if (InvokeRequired)
+        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_ItemsMoved), sender, e);
+      else {
+        IndexedDataRow<T> row = null;
+        valuesRowsTable.TryGetValue((IObservableList<Tuple<T, double>>)sender, out row);
+        if (row != null) {
+          Series rowSeries = chart.Series[row.Name];
+          if (!invisibleSeries.Contains(rowSeries)) {
+            rowSeries.Points.Clear();
+            FillSeriesWithRowValues(rowSeries, row);
+            RecalculateAxesScale(chart.ChartAreas[0]);
+            UpdateYCursorInterval();
+          }
+        }
+      }
+    }
+
+    private void Values_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<Tuple<T, double>>> e) {
+      if (InvokeRequired)
+        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<Tuple<T, double>>>(Values_CollectionReset), sender, e);
+      else {
+        IndexedDataRow<T> row = null;
+        valuesRowsTable.TryGetValue((IObservableList<Tuple<T, double>>)sender, out row);
+        if (row != null) {
+          if (row.Values.Count == 0) {
+            RemoveDataRow(row);
+          } else {
+            Series rowSeries = chart.Series[row.Name];
+            if (!invisibleSeries.Contains(rowSeries)) {
+              rowSeries.Points.Clear();
+              FillSeriesWithRowValues(rowSeries, row);
+              RecalculateAxesScale(chart.ChartAreas[0]);
+              UpdateYCursorInterval();
+            }
+          }
+        }
+      }
+    }
+    #endregion
+    #endregion
+
+    #region Chart Event Handlers
+    private void chart_MouseDown(object sender, MouseEventArgs e) {
+      HitTestResult result = chart.HitTest(e.X, e.Y);
+      if (result.ChartElementType == ChartElementType.LegendItem) {
+        ToggleSeriesVisible(result.Series);
+      }
+    }
+    private void chart_MouseMove(object sender, MouseEventArgs e) {
+      HitTestResult result = chart.HitTest(e.X, e.Y);
+      if (result.ChartElementType == ChartElementType.LegendItem)
+        this.Cursor = Cursors.Hand;
+      else
+        this.Cursor = Cursors.Default;
+    }
+    private void chart_CustomizeLegend(object sender, CustomizeLegendEventArgs e) {
+      foreach (LegendItem legendItem in e.LegendItems) {
+        var series = chart.Series[legendItem.SeriesName];
+        if (series != null) {
+          bool seriesIsInvisible = invisibleSeries.Contains(series);
+          foreach (LegendCell cell in legendItem.Cells) {
+            cell.ForeColor = seriesIsInvisible ? Color.Gray : Color.Black;
+          }
+        }
+      }
+    }
+    #endregion
+
+    private void ToggleSeriesVisible(Series series) {
+      if (!invisibleSeries.Contains(series)) {
+        series.Points.Clear();
+        invisibleSeries.Add(series);
+      } else {
+        invisibleSeries.Remove(series);
+        if (Content != null) {
+
+          var row = (from r in Content.Rows
+                     where r.Name == series.Name
+                     select r).Single();
+          FillSeriesWithRowValues(series, row);
+          this.chart.Legends[series.Legend].ForeColor = Color.Black;
+          RecalculateAxesScale(chart.ChartAreas[0]);
+          UpdateYCursorInterval();
+        }
+      }
+    }
+
+    private void FillSeriesWithRowValues(Series series, IndexedDataRow<T> row) {
+      for (int i = 0; i < row.Values.Count; i++) {
+        var value = row.Values[i];
+        var point = new DataPoint();
+        point.SetValueXY(value.Item1, value.Item2);
+        if (i == row.Values.Count - 1) {
+          point.Label = series.Name;
+          point.MarkerStyle = MarkerStyle.Cross;
+          point.MarkerSize = 15;
+          point.MarkerBorderWidth = 1;
+        }
+        series.Points.Add(point);
+      }
+    }
+
+    #region Helpers
+    protected void RemoveCustomPropertyIfExists(Series series, string property) {
+      if (series.IsCustomPropertySet(property)) series.DeleteCustomProperty(property);
+    }
+
+    private ChartDashStyle ConvertLineStyle(DataRowVisualProperties.DataRowLineStyle dataRowLineStyle) {
+      switch (dataRowLineStyle) {
+        case DataRowVisualProperties.DataRowLineStyle.Dash:
+          return ChartDashStyle.Dash;
+        case DataRowVisualProperties.DataRowLineStyle.DashDot:
+          return ChartDashStyle.DashDot;
+        case DataRowVisualProperties.DataRowLineStyle.DashDotDot:
+          return ChartDashStyle.DashDotDot;
+        case DataRowVisualProperties.DataRowLineStyle.Dot:
+          return ChartDashStyle.Dot;
+        case DataRowVisualProperties.DataRowLineStyle.NotSet:
+          return ChartDashStyle.NotSet;
+        case DataRowVisualProperties.DataRowLineStyle.Solid:
+          return ChartDashStyle.Solid;
+        default:
+          return ChartDashStyle.NotSet;
+      }
+    }
+
+    /// <summary>
+    /// Determines whether a double value can be displayed (converted to Decimal and not an NaN).
+    /// </summary>
+    /// <param name="x">The number to check.</param>
+    /// <returns><code>true</code> if the value can be safely shwon in the chart,
+    /// <code>false</code> otherwise.</returns>
+    protected static bool IsInvalidValue(double x) {
+      return double.IsNaN(x) || x < (double)decimal.MinValue || x > (double)decimal.MaxValue;
+    }
+    #endregion
+  }
+}
Index: /trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataRow.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataRow.cs	(revision 14102)
+++ /trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataRow.cs	(revision 14102)
@@ -0,0 +1,108 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+
+namespace HeuristicLab.Analysis {
+  [Item("IndexedDataRow", "A data row that contains time series.")]
+  [StorableClass]
+  public class IndexedDataRow<T> : NamedItem {
+
+    private DataRowVisualProperties visualProperties;
+    public DataRowVisualProperties VisualProperties {
+      get { return visualProperties; }
+      set {
+        if (visualProperties != value) {
+          if (value == null) throw new ArgumentNullException("VisualProperties");
+          if (visualProperties != null) visualProperties.PropertyChanged -= new PropertyChangedEventHandler(VisualProperties_PropertyChanged);
+          visualProperties = value;
+          visualProperties.PropertyChanged += new PropertyChangedEventHandler(VisualProperties_PropertyChanged);
+          OnVisualPropertiesChanged();
+        }
+      }
+    }
+    private ObservableList<Tuple<T, double>> values;
+    public ObservableList<Tuple<T, double>> Values {
+      get { return values; }
+    }
+
+    #region Persistence Properties
+    [Storable(Name = "visualProperties")]
+    private DataRowVisualProperties StorableVisualProperties {
+      get { return visualProperties; }
+      set { visualProperties = value; }
+    }
+    [Storable(Name = "values")]
+    private IEnumerable<Tuple<T, double>> StorableValues {
+      get { return values; }
+      set { values = new ObservableList<Tuple<T, double>>(value); }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected IndexedDataRow(bool deserializing) : base(deserializing) { }
+    protected IndexedDataRow(IndexedDataRow<T> original, Cloner cloner)
+      : base(original, cloner) {
+      values = new ObservableList<Tuple<T, double>>(original.values.Select(x => Tuple.Create<T, double>(x.Item1, x.Item2)).ToList());
+      VisualProperties = cloner.Clone(original.visualProperties);
+    }
+    public IndexedDataRow() {
+      values = new ObservableList<Tuple<T, double>>();
+      VisualProperties = new DataRowVisualProperties();
+    }
+    public IndexedDataRow(string name)
+      : base(name) {
+      values = new ObservableList<Tuple<T, double>>();
+      VisualProperties = new DataRowVisualProperties(name);
+    }
+    public IndexedDataRow(string name, string description)
+      : base(name, description) {
+      values = new ObservableList<Tuple<T, double>>();
+      VisualProperties = new DataRowVisualProperties(name);
+    }
+    public IndexedDataRow(string name, string description, IEnumerable<Tuple<T, double>> values)
+      : base(name, description) {
+      this.values = new ObservableList<Tuple<T, double>>(values);
+      VisualProperties = new DataRowVisualProperties(name);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IndexedDataRow<T>(this, cloner);
+    }
+
+    public event EventHandler VisualPropertiesChanged;
+    protected virtual void OnVisualPropertiesChanged() {
+      EventHandler handler = VisualPropertiesChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    private void VisualProperties_PropertyChanged(object sender, PropertyChangedEventArgs e) {
+      OnVisualPropertiesChanged();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataTable.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataTable.cs	(revision 14102)
+++ /trunk/sources/HeuristicLab.Analysis/3.3/DataVisualization/IndexedDataTable.cs	(revision 14102)
@@ -0,0 +1,278 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Linq;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Analysis {
+  [Item("IndexedDataTable", "A data table where the points are also given with a certain index.")]
+  [StorableClass]
+  public class IndexedDataTable<T> : NamedItem, IStringConvertibleMatrix {
+    public static new Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Performance; }
+    }
+
+    private DataTableVisualProperties visualProperties;
+    public DataTableVisualProperties VisualProperties {
+      get { return visualProperties; }
+      set {
+        if (visualProperties != value) {
+          if (value == null) throw new ArgumentNullException("VisualProperties");
+          if (visualProperties != null) visualProperties.PropertyChanged -= new PropertyChangedEventHandler(VisualProperties_PropertyChanged);
+          visualProperties = value;
+          visualProperties.PropertyChanged += new PropertyChangedEventHandler(VisualProperties_PropertyChanged);
+          OnVisualPropertiesChanged();
+        }
+      }
+    }
+
+    private NamedItemCollection<IndexedDataRow<T>> rows;
+    public NamedItemCollection<IndexedDataRow<T>> Rows {
+      get { return rows; }
+    }
+
+    #region Persistence Properties
+    [Storable(Name = "VisualProperties")]
+    private DataTableVisualProperties StorableVisualProperties {
+      get { return visualProperties; }
+      set {
+        visualProperties = value;
+        visualProperties.PropertyChanged += new PropertyChangedEventHandler(VisualProperties_PropertyChanged);
+      }
+    }
+    [Storable(Name = "rows")]
+    private IEnumerable<IndexedDataRow<T>> StorableRows {
+      get { return rows; }
+      set { rows = new NamedItemCollection<IndexedDataRow<T>>(value); }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected IndexedDataTable(bool deserializing) : base(deserializing) { }
+    protected IndexedDataTable(IndexedDataTable<T> original, Cloner cloner)
+      : base(original, cloner) {
+      VisualProperties = (DataTableVisualProperties)cloner.Clone(original.visualProperties);
+      rows = cloner.Clone(original.rows);
+      this.RegisterRowsEvents();
+    }
+    public IndexedDataTable()
+      : base() {
+      VisualProperties = new DataTableVisualProperties();
+      rows = new NamedItemCollection<IndexedDataRow<T>>();
+      this.RegisterRowsEvents();
+    }
+    public IndexedDataTable(string name)
+      : base(name) {
+      VisualProperties = new DataTableVisualProperties();
+      rows = new NamedItemCollection<IndexedDataRow<T>>();
+      this.RegisterRowsEvents();
+    }
+    public IndexedDataTable(string name, string description)
+      : base(name, description) {
+      VisualProperties = new DataTableVisualProperties();
+      rows = new NamedItemCollection<IndexedDataRow<T>>();
+      this.RegisterRowsEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IndexedDataTable<T>(this, cloner);
+    }
+
+    public event EventHandler VisualPropertiesChanged;
+    protected virtual void OnVisualPropertiesChanged() {
+      EventHandler handler = VisualPropertiesChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    private void VisualProperties_PropertyChanged(object sender, PropertyChangedEventArgs e) {
+      OnVisualPropertiesChanged();
+    }
+
+    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) {
+      foreach (var row in e.Items)
+        this.RegisterRowEvents(row);
+
+      this.OnColumnsChanged();
+      this.OnColumnNamesChanged();
+      this.OnReset();
+    }
+    private void rows_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+      foreach (var row in e.Items)
+        this.DeregisterRowEvents(row);
+
+      this.OnColumnsChanged();
+      this.OnColumnNamesChanged();
+      this.OnReset();
+    }
+    private void rows_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+      foreach (var row in e.OldItems)
+        this.DeregisterRowEvents(row);
+      foreach (var row in e.Items)
+        this.RegisterRowEvents(row);
+
+      this.OnColumnsChanged();
+      this.OnColumnNamesChanged();
+      this.OnReset();
+    }
+    private void rows_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedDataRow<T>> e) {
+      foreach (var row in e.OldItems)
+        this.DeregisterRowEvents(row);
+      foreach (var row in e.Items)
+        this.RegisterRowEvents(row);
+
+      if (e.OldItems.Count() != e.Items.Count())
+        this.OnColumnsChanged();
+      this.OnColumnNamesChanged();
+      this.OnReset();
+    }
+
+    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) {
+      this.OnReset();
+    }
+
+    #region IStringConvertibleMatrix Members
+
+    int IStringConvertibleMatrix.Rows {
+      get { return rows.Count == 0 ? 0 : rows.Max(r => r.Values.Count); }
+      set { throw new NotSupportedException(); }
+    }
+    int IStringConvertibleMatrix.Columns {
+      get { return rows.Count * 2; }
+      set { throw new NotSupportedException(); }
+    }
+    IEnumerable<string> IStringConvertibleMatrix.ColumnNames {
+      get { return rows.Select(r => new string[] { r.Name + " Index", r.Name }).SelectMany(x => x); }
+      set { throw new NotSupportedException(); }
+    }
+    IEnumerable<string> IStringConvertibleMatrix.RowNames {
+      get { return new List<string>(); }
+      set { throw new NotSupportedException(); }
+    }
+
+    bool IStringConvertibleMatrix.SortableView {
+      get { return true; }
+      set { throw new NotSupportedException(); }
+    }
+    bool IStringConvertibleMatrix.ReadOnly {
+      get { return true; }
+    }
+
+    string IStringConvertibleMatrix.GetValue(int rowIndex, int columnIndex) {
+      if (columnIndex < rows.Count * 2) {
+        string columnName = ((IStringConvertibleMatrix)this).ColumnNames.ElementAt(columnIndex);
+        if (!rows.ContainsKey(columnName) && columnName.Length > " Index".Length) {
+          columnName = columnName.Substring(0, columnName.Length - " Index".Length);
+          if (rows.ContainsKey(columnName) && rowIndex < rows[columnName].Values.Count)
+            return rows[columnName].Values[rowIndex].Item1.ToString();
+          else return string.Empty;
+        } else if (rows.ContainsKey(columnName) && rowIndex < rows[columnName].Values.Count)
+          return rows[columnName].Values[rowIndex].Item2.ToString();
+      }
+      return string.Empty;
+    }
+
+    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
+      throw new NotSupportedException();
+    }
+    bool IStringConvertibleMatrix.SetValue(string value, int rowIndex, int columnIndex) {
+      throw new NotSupportedException();
+    }
+
+    public event EventHandler<EventArgs<int, int>> ItemChanged;
+    protected virtual void OnItemChanged(int rowIndex, int columnIndex) {
+      var handler = ItemChanged;
+      if (handler != null) handler(this, new EventArgs<int, int>(rowIndex, columnIndex));
+      OnToStringChanged();
+    }
+    public event EventHandler Reset;
+    protected virtual void OnReset() {
+      var handler = Reset;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ColumnsChanged;
+    protected virtual void OnColumnsChanged() {
+      var handler = ColumnsChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler RowsChanged;
+    protected virtual void OnRowsChanged() {
+      var handler = RowsChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ColumnNamesChanged;
+    protected virtual void OnColumnNamesChanged() {
+      var handler = ColumnNamesChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler RowNamesChanged;
+    protected virtual void OnRowNamesChanged() {
+      var handler = RowNamesChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler SortableViewChanged;
+    protected virtual void OnSortableViewChanged() {
+      var handler = SortableViewChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #endregion
+  }
+}
Index: /trunk/sources/HeuristicLab.Analysis/3.3/HeuristicLab.Analysis-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Analysis/3.3/HeuristicLab.Analysis-3.3.csproj	(revision 14101)
+++ /trunk/sources/HeuristicLab.Analysis/3.3/HeuristicLab.Analysis-3.3.csproj	(revision 14102)
@@ -131,4 +131,6 @@
     <Compile Include="AlleleFrequencyAnalysis\AlleleFrequencyCollectionHistory.cs" />
     <Compile Include="BestScopeSolutionAnalyzer.cs" />
+    <Compile Include="DataVisualization\IndexedDataRow.cs" />
+    <Compile Include="DataVisualization\IndexedDataTable.cs" />
     <Compile Include="DataVisualization\ScatterPlotDataRowVisualProperties.cs" />
     <Compile Include="DataVisualization\ScatterPlotDataRow.cs" />
@@ -154,4 +156,5 @@
     <Compile Include="QualityAnalysis\BestAverageWorstQualityCalculator.cs" />
     <Compile Include="QualityAnalysis\BestQualityMemorizer.cs" />
+    <Compile Include="QualityAnalysis\ExpectedRuntimeHelper.cs" />
     <Compile Include="QualityAnalysis\QualityAnalyzer.cs" />
     <Compile Include="QualityAnalysis\QualityDifferenceCalculator.cs" />
@@ -159,4 +162,6 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="QualityAnalysis\QualityDistributionAnalyzer.cs" />
+    <Compile Include="QualityAnalysis\QualityPerClockAnalyzer.cs" />
+    <Compile Include="QualityAnalysis\QualityPerEvaluationsAnalyzer.cs" />
     <Compile Include="QualityAnalysis\ScaledQualityDifferenceAnalyzer.cs" />
     <Compile Include="Statistics\BonferroniHolm.cs" />
Index: /trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/ExpectedRuntimeHelper.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/ExpectedRuntimeHelper.cs	(revision 14102)
+++ /trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/ExpectedRuntimeHelper.cs	(revision 14102)
@@ -0,0 +1,63 @@
+﻿using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace HeuristicLab.Analysis {
+  public static class ExpectedRuntimeHelper {
+    public static ErtCalculationResult CalculateErt(IEnumerable<IEnumerable<Tuple<double, double>>> convGraphs, double target, bool maximization) {
+      var successful = new List<double>();
+      var unsuccessful = new List<double>();
+      foreach (var graph in convGraphs) {
+        var targetAchieved = false;
+        var lastEffort = double.MaxValue;
+        foreach (var v in graph) {
+          if (maximization && v.Item2 >= target || !maximization && v.Item2 <= target) {
+            successful.Add(v.Item1);
+            targetAchieved = true;
+            break;
+          }
+          lastEffort = v.Item1;
+        }
+        if (!targetAchieved) unsuccessful.Add(lastEffort);
+      }
+
+      var ert = double.PositiveInfinity;
+
+      var nRuns = successful.Count + unsuccessful.Count;
+      if (successful.Count > 0) {
+        var succAvg = successful.Average();
+        var succDev = successful.StandardDeviation();
+        successful.RemoveAll(x => x < succAvg - 2 * succDev);
+        unsuccessful.RemoveAll(x => x < succAvg - 2 * succDev);
+        nRuns = successful.Count + unsuccessful.Count;
+
+        ert = successful.Average() / (successful.Count / (double)nRuns);
+      }
+      return new ErtCalculationResult(successful.Count, nRuns, ert);
+    }
+
+    public static ErtCalculationResult CalculateErt(List<IRun> runs, string indexedDataTableName, double target, bool maximization) {
+      return CalculateErt(runs.Select(r => ((IndexedDataTable<double>)r.Results[indexedDataTableName]).Rows.First().Values), target, maximization);
+    }
+  }
+
+  public struct ErtCalculationResult {
+    public int SuccessfulRuns;
+    public int TotalRuns;
+    public double ExpectedRuntime;
+
+    public ErtCalculationResult(int successful, int total, double ert) {
+      SuccessfulRuns = successful;
+      TotalRuns = total;
+      ExpectedRuntime = ert;
+    }
+
+    public override string ToString() {
+      return SuccessfulRuns == 0 ? "\u221e" // infinity symbol
+                                 : 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 14102)
+++ /trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerClockAnalyzer.cs	(revision 14102)
@@ -0,0 +1,108 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Analysis {
+  [Item("QualityPerClockAnalyzer", @"Creates a plot of the solution quality with respect to the elapsed wall-clock time.")]
+  [StorableClass]
+  public class QualityPerClockAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator {
+    public virtual bool EnabledByDefault {
+      get { return false; }
+    }
+
+    public ILookupParameter<DoubleValue> BestQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestQuality"]; }
+    }
+
+    public ILookupParameter<DateTimeValue> LastUpdateTimeParameter {
+      get { return (ILookupParameter<DateTimeValue>)Parameters["LastUpdateTime"]; }
+    }
+
+    public IResultParameter<IndexedDataTable<double>> QualityPerClockParameter {
+      get { return (IResultParameter<IndexedDataTable<double>>)Parameters["QualityPerClock"]; }
+    }
+
+    [StorableConstructor]
+    protected QualityPerClockAnalyzer(bool deserializing) : base(deserializing) { }
+    protected QualityPerClockAnalyzer(QualityPerClockAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public QualityPerClockAnalyzer()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("BestQuality", "The quality value that should be compared."));
+      Parameters.Add(new LookupParameter<DateTimeValue>("LastUpdateTime", "The time the analyzer was last run."));
+      Parameters.Add(new ResultParameter<IndexedDataTable<double>>("QualityPerClock", "Data table containing the first hitting graph with elapsed wall clock time (in seconds) as the x-axis."));
+      QualityPerClockParameter.DefaultValue = new IndexedDataTable<double>("Quality per Clock") {
+        VisualProperties = {
+          XAxisTitle = "Elapsed time [s]",
+          YAxisTitle = "Quality"
+        },
+        Rows = { new IndexedDataRow<double>("First-hit Graph") { VisualProperties = {
+          ChartType = DataRowVisualProperties.DataRowChartType.StepLine,
+          LineWidth = 2
+        } } }
+      };
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new QualityPerClockAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var bestQuality = BestQualityParameter.ActualValue.Value;
+      var dataTable = QualityPerClockParameter.ActualValue;
+      var values = dataTable.Rows["First-hit Graph"].Values;
+
+      var lastUpdateTime = LastUpdateTimeParameter.ActualValue;
+      if (lastUpdateTime == null) {
+        lastUpdateTime = new DateTimeValue(DateTime.UtcNow.AddMilliseconds(-1));
+        LastUpdateTimeParameter.ActualValue = lastUpdateTime;
+      }
+
+      var now = DateTime.UtcNow;
+      var runtimeSoFar = (now - lastUpdateTime.Value).TotalSeconds + (values.Count > 0 ? values.Last().Item1 : 0);
+      lastUpdateTime.Value = now;
+      var newEntry = Tuple.Create(runtimeSoFar, bestQuality);
+
+      if (values.Count == 0) {
+        values.Add(newEntry);
+        values.Add(Tuple.Create(runtimeSoFar, bestQuality)); // duplicate entry that will be replaced
+        return base.Apply();
+      }
+
+      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
+      } else {
+        values[values.Count - 1] = Tuple.Create(runtimeSoFar, bestQuality);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerEvaluationsAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerEvaluationsAnalyzer.cs	(revision 14102)
+++ /trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityPerEvaluationsAnalyzer.cs	(revision 14102)
@@ -0,0 +1,111 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Analysis {
+  [Item("QualityPerEvaluationsAnalyzer", @"Creates a plot of the solution quality with respect to the number of evaluated solutions.")]
+  [StorableClass]
+  public class QualityPerEvaluationsAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator {
+    public virtual bool EnabledByDefault {
+      get { return false; }
+    }
+
+    public ILookupParameter<DoubleValue> BestQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestQuality"]; }
+    }
+    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+    public ILookupParameter<IntValue> EvaluatedMovesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedMoves"]; }
+    }
+    public IValueLookupParameter<DoubleValue> MoveCostPerSolutionParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["MoveCostPerSolution"]; }
+    }
+    public IResultParameter<IndexedDataTable<double>> QualityPerEvaluationsParameter {
+      get { return (IResultParameter<IndexedDataTable<double>>)Parameters["QualityPerEvaluations"]; }
+    }
+
+    [StorableConstructor]
+    protected QualityPerEvaluationsAnalyzer(bool deserializing) : base(deserializing) { }
+    protected QualityPerEvaluationsAnalyzer(QualityPerEvaluationsAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public QualityPerEvaluationsAnalyzer()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("BestQuality", "The quality value that should be compared."));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of evaluated moves."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MoveCostPerSolution", "The cost to evaluate a move as a ratio to the cost of evaluating a solution.", new DoubleValue(1)));
+      Parameters.Add(new ResultParameter<IndexedDataTable<double>>("QualityPerEvaluations", "Data table containing the first hitting graph with evaluations as the x-axis."));
+      QualityPerEvaluationsParameter.DefaultValue = new IndexedDataTable<double>("Quality per Evaluations") {
+        VisualProperties = {
+          XAxisTitle = "Evaluations",
+          YAxisTitle = "Quality"
+        },
+        Rows = { new IndexedDataRow<double>("First-hit Graph") { VisualProperties = {
+          ChartType = DataRowVisualProperties.DataRowChartType.StepLine,
+          LineWidth = 2
+        } } }
+      };
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new QualityPerEvaluationsAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var bestQuality = BestQualityParameter.ActualValue.Value;
+      var evalSols = EvaluatedSolutionsParameter.ActualValue;
+      var evalMoves = EvaluatedMovesParameter.ActualValue;
+      var evaluations = 0.0;
+      if (evalSols != null) evaluations += evalSols.Value;
+      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 (values.Count == 0) {
+        values.Add(newEntry);
+        values.Add(Tuple.Create(evaluations, bestQuality)); // duplicate entry that will be replaced
+        return base.Apply();
+      }
+
+      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);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Optimization.Views/3.3/HeuristicLab.Optimization.Views-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Optimization.Views/3.3/HeuristicLab.Optimization.Views-3.3.csproj	(revision 14101)
+++ /trunk/sources/HeuristicLab.Optimization.Views/3.3/HeuristicLab.Optimization.Views-3.3.csproj	(revision 14102)
@@ -269,4 +269,10 @@
       <DependentUpon>RunCollectionEqualityConstraintView.cs</DependentUpon>
     </Compile>
+    <Compile Include="RunCollectionViews\RunCollectionRLDView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="RunCollectionViews\RunCollectionRLDView.Designer.cs">
+      <DependentUpon>RunCollectionRLDView.cs</DependentUpon>
+    </Compile>
     <Compile Include="RunCollectionViews\RunCollectionTableView.cs">
       <SubType>UserControl</SubType>
Index: /trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.Designer.cs	(revision 14102)
+++ /trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.Designer.cs	(revision 14102)
@@ -0,0 +1,476 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+namespace HeuristicLab.Optimization.Views {
+  partial class RunCollectionRLDView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.components = new System.ComponentModel.Container();
+      System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea1 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
+      System.Windows.Forms.DataVisualization.Charting.Legend legend1 = new System.Windows.Forms.DataVisualization.Charting.Legend();
+      this.dataTableComboBox = new System.Windows.Forms.ComboBox();
+      this.dataTableLabel = new System.Windows.Forms.Label();
+      this.groupLabel = new System.Windows.Forms.Label();
+      this.groupComboBox = new System.Windows.Forms.ComboBox();
+      this.targetLogScalingCheckBox = new System.Windows.Forms.CheckBox();
+      this.targetsTextBox = new System.Windows.Forms.TextBox();
+      this.targetsLabel = new System.Windows.Forms.Label();
+      this.errorProvider = new System.Windows.Forms.ErrorProvider(this.components);
+      this.addTargetsAsResultButton = new System.Windows.Forms.Button();
+      this.generateTargetsButton = new System.Windows.Forms.Button();
+      this.toolTip = new System.Windows.Forms.ToolTip(this.components);
+      this.budgetsLabel = new System.Windows.Forms.Label();
+      this.budgetsTextBox = new System.Windows.Forms.TextBox();
+      this.addBudgetsAsResultButton = new System.Windows.Forms.Button();
+      this.aggregateTargetsCheckBox = new System.Windows.Forms.CheckBox();
+      this.tabControl = new System.Windows.Forms.TabControl();
+      this.byTargetTabPage = new System.Windows.Forms.TabPage();
+      this.targetChart = new HeuristicLab.Visualization.ChartControlsExtensions.EnhancedChart();
+      this.boundShadingCheckBox = new System.Windows.Forms.CheckBox();
+      this.byCostTabPage = new System.Windows.Forms.TabPage();
+      this.byCostViewHost = new HeuristicLab.MainForm.WindowsForms.ViewHost();
+      this.budgetLogScalingCheckBox = new System.Windows.Forms.CheckBox();
+      this.eachOrAllBudgetsCheckBox = new System.Windows.Forms.CheckBox();
+      this.generateBudgetsButton = new System.Windows.Forms.Button();
+      this.byTableTabPage = new System.Windows.Forms.TabPage();
+      this.ertTableView = new HeuristicLab.Data.Views.StringConvertibleMatrixView();
+      this.problemComboBox = new System.Windows.Forms.ComboBox();
+      this.problemLabel = new System.Windows.Forms.Label();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      this.tabControl.SuspendLayout();
+      this.byTargetTabPage.SuspendLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.targetChart)).BeginInit();
+      this.byCostTabPage.SuspendLayout();
+      this.byTableTabPage.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // dataTableComboBox
+      // 
+      this.dataTableComboBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.dataTableComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
+      this.dataTableComboBox.FormattingEnabled = true;
+      this.dataTableComboBox.Location = new System.Drawing.Point(69, 57);
+      this.dataTableComboBox.Name = "dataTableComboBox";
+      this.dataTableComboBox.Size = new System.Drawing.Size(582, 21);
+      this.dataTableComboBox.TabIndex = 5;
+      this.dataTableComboBox.SelectedIndexChanged += new System.EventHandler(this.dataTableComboBox_SelectedIndexChanged);
+      // 
+      // dataTableLabel
+      // 
+      this.dataTableLabel.AutoSize = true;
+      this.dataTableLabel.Location = new System.Drawing.Point(3, 60);
+      this.dataTableLabel.Name = "dataTableLabel";
+      this.dataTableLabel.Size = new System.Drawing.Size(60, 13);
+      this.dataTableLabel.TabIndex = 4;
+      this.dataTableLabel.Text = "DataTable:";
+      // 
+      // groupLabel
+      // 
+      this.groupLabel.AutoSize = true;
+      this.groupLabel.Location = new System.Drawing.Point(3, 6);
+      this.groupLabel.Name = "groupLabel";
+      this.groupLabel.Size = new System.Drawing.Size(39, 13);
+      this.groupLabel.TabIndex = 0;
+      this.groupLabel.Text = "Group:";
+      // 
+      // groupComboBox
+      // 
+      this.groupComboBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.groupComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
+      this.groupComboBox.FormattingEnabled = true;
+      this.groupComboBox.Location = new System.Drawing.Point(69, 3);
+      this.groupComboBox.Name = "groupComboBox";
+      this.groupComboBox.Size = new System.Drawing.Size(582, 21);
+      this.groupComboBox.TabIndex = 1;
+      this.groupComboBox.SelectedIndexChanged += new System.EventHandler(this.groupComboBox_SelectedIndexChanged);
+      // 
+      // targetLogScalingCheckBox
+      // 
+      this.targetLogScalingCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.targetLogScalingCheckBox.AutoSize = true;
+      this.targetLogScalingCheckBox.Location = new System.Drawing.Point(9, 364);
+      this.targetLogScalingCheckBox.Name = "targetLogScalingCheckBox";
+      this.targetLogScalingCheckBox.Size = new System.Drawing.Size(112, 17);
+      this.targetLogScalingCheckBox.TabIndex = 6;
+      this.targetLogScalingCheckBox.Text = "logarithmic scaling";
+      this.targetLogScalingCheckBox.UseVisualStyleBackColor = true;
+      this.targetLogScalingCheckBox.CheckedChanged += new System.EventHandler(this.logScalingCheckBox_CheckedChanged);
+      // 
+      // targetsTextBox
+      // 
+      this.targetsTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.targetsTextBox.Location = new System.Drawing.Point(59, 8);
+      this.targetsTextBox.Name = "targetsTextBox";
+      this.targetsTextBox.Size = new System.Drawing.Size(287, 20);
+      this.targetsTextBox.TabIndex = 1;
+      this.toolTip.SetToolTip(this.targetsTextBox, "The order of the targets is important, first to-hit targets\r\nshould be given firs" +
+        "t. The sequence should be monotonous.\r\n\r\nTargets should be separated by semicolo" +
+        "n, tab or space.");
+      this.targetsTextBox.Validating += new System.ComponentModel.CancelEventHandler(this.targetsTextBox_Validating);
+      // 
+      // targetsLabel
+      // 
+      this.targetsLabel.AutoSize = true;
+      this.targetsLabel.Location = new System.Drawing.Point(6, 11);
+      this.targetsLabel.Name = "targetsLabel";
+      this.targetsLabel.Size = new System.Drawing.Size(46, 13);
+      this.targetsLabel.TabIndex = 0;
+      this.targetsLabel.Text = "Targets:";
+      // 
+      // errorProvider
+      // 
+      this.errorProvider.ContainerControl = this;
+      // 
+      // addTargetsAsResultButton
+      // 
+      this.addTargetsAsResultButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+      this.addTargetsAsResultButton.Location = new System.Drawing.Point(551, 6);
+      this.addTargetsAsResultButton.Name = "addTargetsAsResultButton";
+      this.addTargetsAsResultButton.Size = new System.Drawing.Size(89, 23);
+      this.addTargetsAsResultButton.TabIndex = 4;
+      this.addTargetsAsResultButton.Text = "Add as Result";
+      this.addTargetsAsResultButton.UseVisualStyleBackColor = true;
+      this.addTargetsAsResultButton.Click += new System.EventHandler(this.addTargetsAsResultButton_Click);
+      // 
+      // generateTargetsButton
+      // 
+      this.generateTargetsButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+      this.generateTargetsButton.Location = new System.Drawing.Point(456, 6);
+      this.generateTargetsButton.Name = "generateTargetsButton";
+      this.generateTargetsButton.Size = new System.Drawing.Size(89, 23);
+      this.generateTargetsButton.TabIndex = 3;
+      this.generateTargetsButton.Text = "Generate...";
+      this.generateTargetsButton.UseVisualStyleBackColor = true;
+      this.generateTargetsButton.Click += new System.EventHandler(this.generateTargetsButton_Click);
+      // 
+      // budgetsLabel
+      // 
+      this.budgetsLabel.AutoSize = true;
+      this.budgetsLabel.Location = new System.Drawing.Point(6, 11);
+      this.budgetsLabel.Name = "budgetsLabel";
+      this.budgetsLabel.Size = new System.Drawing.Size(49, 13);
+      this.budgetsLabel.TabIndex = 1;
+      this.budgetsLabel.Text = "Budgets:";
+      // 
+      // budgetsTextBox
+      // 
+      this.budgetsTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.budgetsTextBox.Location = new System.Drawing.Point(59, 8);
+      this.budgetsTextBox.Name = "budgetsTextBox";
+      this.budgetsTextBox.Size = new System.Drawing.Size(326, 20);
+      this.budgetsTextBox.TabIndex = 6;
+      this.budgetsTextBox.Validating += new System.ComponentModel.CancelEventHandler(this.budgetsTextBox_Validating);
+      // 
+      // addBudgetsAsResultButton
+      // 
+      this.addBudgetsAsResultButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+      this.addBudgetsAsResultButton.Location = new System.Drawing.Point(551, 6);
+      this.addBudgetsAsResultButton.Name = "addBudgetsAsResultButton";
+      this.addBudgetsAsResultButton.Size = new System.Drawing.Size(89, 23);
+      this.addBudgetsAsResultButton.TabIndex = 7;
+      this.addBudgetsAsResultButton.Text = "Add as Result";
+      this.addBudgetsAsResultButton.UseVisualStyleBackColor = true;
+      this.addBudgetsAsResultButton.Click += new System.EventHandler(this.addBudgetsAsResultButton_Click);
+      // 
+      // aggregateTargetsCheckBox
+      // 
+      this.aggregateTargetsCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+      this.aggregateTargetsCheckBox.AutoSize = true;
+      this.aggregateTargetsCheckBox.Checked = true;
+      this.aggregateTargetsCheckBox.CheckState = System.Windows.Forms.CheckState.Checked;
+      this.aggregateTargetsCheckBox.Location = new System.Drawing.Point(352, 10);
+      this.aggregateTargetsCheckBox.Name = "aggregateTargetsCheckBox";
+      this.aggregateTargetsCheckBox.Size = new System.Drawing.Size(74, 17);
+      this.aggregateTargetsCheckBox.TabIndex = 2;
+      this.aggregateTargetsCheckBox.Text = "aggregate";
+      this.aggregateTargetsCheckBox.UseVisualStyleBackColor = true;
+      this.aggregateTargetsCheckBox.CheckedChanged += new System.EventHandler(this.aggregateTargetsCheckBox_CheckedChanged);
+      // 
+      // tabControl
+      // 
+      this.tabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.tabControl.Controls.Add(this.byTargetTabPage);
+      this.tabControl.Controls.Add(this.byCostTabPage);
+      this.tabControl.Controls.Add(this.byTableTabPage);
+      this.tabControl.Location = new System.Drawing.Point(0, 84);
+      this.tabControl.Name = "tabControl";
+      this.tabControl.SelectedIndex = 0;
+      this.tabControl.Size = new System.Drawing.Size(654, 413);
+      this.tabControl.TabIndex = 6;
+      // 
+      // byTargetTabPage
+      // 
+      this.byTargetTabPage.Controls.Add(this.targetChart);
+      this.byTargetTabPage.Controls.Add(this.boundShadingCheckBox);
+      this.byTargetTabPage.Controls.Add(this.targetLogScalingCheckBox);
+      this.byTargetTabPage.Controls.Add(this.targetsLabel);
+      this.byTargetTabPage.Controls.Add(this.aggregateTargetsCheckBox);
+      this.byTargetTabPage.Controls.Add(this.targetsTextBox);
+      this.byTargetTabPage.Controls.Add(this.generateTargetsButton);
+      this.byTargetTabPage.Controls.Add(this.addTargetsAsResultButton);
+      this.byTargetTabPage.Location = new System.Drawing.Point(4, 22);
+      this.byTargetTabPage.Name = "byTargetTabPage";
+      this.byTargetTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.byTargetTabPage.Size = new System.Drawing.Size(646, 387);
+      this.byTargetTabPage.TabIndex = 0;
+      this.byTargetTabPage.Text = "Performance by Target";
+      this.byTargetTabPage.UseVisualStyleBackColor = true;
+      // 
+      // targetChart
+      // 
+      this.targetChart.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      chartArea1.AxisX.IsStartedFromZero = false;
+      chartArea1.AxisX.MinorGrid.Enabled = true;
+      chartArea1.AxisX.MinorGrid.LineColor = System.Drawing.Color.WhiteSmoke;
+      chartArea1.AxisX.MinorGrid.LineDashStyle = System.Windows.Forms.DataVisualization.Charting.ChartDashStyle.Dash;
+      chartArea1.AxisY.Maximum = 1D;
+      chartArea1.AxisY.Minimum = 0D;
+      chartArea1.AxisY.MinorGrid.Enabled = true;
+      chartArea1.AxisY.MinorGrid.LineColor = System.Drawing.Color.WhiteSmoke;
+      chartArea1.AxisY.MinorGrid.LineDashStyle = System.Windows.Forms.DataVisualization.Charting.ChartDashStyle.Dash;
+      chartArea1.Name = "ChartArea1";
+      this.targetChart.ChartAreas.Add(chartArea1);
+      legend1.Alignment = System.Drawing.StringAlignment.Center;
+      legend1.Docking = System.Windows.Forms.DataVisualization.Charting.Docking.Top;
+      legend1.Name = "Legend1";
+      this.targetChart.Legends.Add(legend1);
+      this.targetChart.Location = new System.Drawing.Point(6, 34);
+      this.targetChart.Name = "targetChart";
+      this.targetChart.Size = new System.Drawing.Size(634, 324);
+      this.targetChart.SuppressExceptions = true;
+      this.targetChart.TabIndex = 7;
+      this.targetChart.Text = "enhancedChart1";
+      this.targetChart.CustomizeLegend += new System.EventHandler<System.Windows.Forms.DataVisualization.Charting.CustomizeLegendEventArgs>(this.chart_CustomizeLegend);
+      this.targetChart.MouseDown += new System.Windows.Forms.MouseEventHandler(this.chart_MouseDown);
+      this.targetChart.MouseMove += new System.Windows.Forms.MouseEventHandler(this.chart_MouseMove);
+      // 
+      // boundShadingCheckBox
+      // 
+      this.boundShadingCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.boundShadingCheckBox.AutoSize = true;
+      this.boundShadingCheckBox.Checked = true;
+      this.boundShadingCheckBox.CheckState = System.Windows.Forms.CheckState.Checked;
+      this.boundShadingCheckBox.Location = new System.Drawing.Point(127, 364);
+      this.boundShadingCheckBox.Name = "boundShadingCheckBox";
+      this.boundShadingCheckBox.Size = new System.Drawing.Size(96, 17);
+      this.boundShadingCheckBox.TabIndex = 6;
+      this.boundShadingCheckBox.Text = "bound shading";
+      this.boundShadingCheckBox.UseVisualStyleBackColor = true;
+      this.boundShadingCheckBox.CheckedChanged += new System.EventHandler(this.boundShadingCheckBox_CheckedChanged);
+      // 
+      // byCostTabPage
+      // 
+      this.byCostTabPage.Controls.Add(this.byCostViewHost);
+      this.byCostTabPage.Controls.Add(this.budgetLogScalingCheckBox);
+      this.byCostTabPage.Controls.Add(this.eachOrAllBudgetsCheckBox);
+      this.byCostTabPage.Controls.Add(this.generateBudgetsButton);
+      this.byCostTabPage.Controls.Add(this.budgetsLabel);
+      this.byCostTabPage.Controls.Add(this.addBudgetsAsResultButton);
+      this.byCostTabPage.Controls.Add(this.budgetsTextBox);
+      this.byCostTabPage.Location = new System.Drawing.Point(4, 22);
+      this.byCostTabPage.Name = "byCostTabPage";
+      this.byCostTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.byCostTabPage.Size = new System.Drawing.Size(646, 387);
+      this.byCostTabPage.TabIndex = 1;
+      this.byCostTabPage.Text = "Performance by Cost";
+      this.byCostTabPage.UseVisualStyleBackColor = true;
+      // 
+      // byCostViewHost
+      // 
+      this.byCostViewHost.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.byCostViewHost.Caption = "View";
+      this.byCostViewHost.Content = null;
+      this.byCostViewHost.Enabled = false;
+      this.byCostViewHost.Location = new System.Drawing.Point(6, 34);
+      this.byCostViewHost.Name = "byCostViewHost";
+      this.byCostViewHost.ReadOnly = false;
+      this.byCostViewHost.Size = new System.Drawing.Size(634, 324);
+      this.byCostViewHost.TabIndex = 12;
+      this.byCostViewHost.ViewsLabelVisible = true;
+      this.byCostViewHost.ViewType = null;
+      // 
+      // budgetLogScalingCheckBox
+      // 
+      this.budgetLogScalingCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.budgetLogScalingCheckBox.AutoSize = true;
+      this.budgetLogScalingCheckBox.Location = new System.Drawing.Point(9, 364);
+      this.budgetLogScalingCheckBox.Name = "budgetLogScalingCheckBox";
+      this.budgetLogScalingCheckBox.Size = new System.Drawing.Size(112, 17);
+      this.budgetLogScalingCheckBox.TabIndex = 11;
+      this.budgetLogScalingCheckBox.Text = "logarithmic scaling";
+      this.budgetLogScalingCheckBox.UseVisualStyleBackColor = true;
+      this.budgetLogScalingCheckBox.CheckedChanged += new System.EventHandler(this.logScalingCheckBox_CheckedChanged);
+      // 
+      // eachOrAllBudgetsCheckBox
+      // 
+      this.eachOrAllBudgetsCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+      this.eachOrAllBudgetsCheckBox.AutoSize = true;
+      this.eachOrAllBudgetsCheckBox.Location = new System.Drawing.Point(414, 10);
+      this.eachOrAllBudgetsCheckBox.Name = "eachOrAllBudgetsCheckBox";
+      this.eachOrAllBudgetsCheckBox.Size = new System.Drawing.Size(36, 17);
+      this.eachOrAllBudgetsCheckBox.TabIndex = 10;
+      this.eachOrAllBudgetsCheckBox.Text = "all";
+      this.eachOrAllBudgetsCheckBox.UseVisualStyleBackColor = true;
+      this.eachOrAllBudgetsCheckBox.CheckedChanged += new System.EventHandler(this.eachOrAllBudgetsCheckBox_CheckedChanged);
+      // 
+      // generateBudgetsButton
+      // 
+      this.generateBudgetsButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+      this.generateBudgetsButton.Location = new System.Drawing.Point(456, 6);
+      this.generateBudgetsButton.Name = "generateBudgetsButton";
+      this.generateBudgetsButton.Size = new System.Drawing.Size(89, 23);
+      this.generateBudgetsButton.TabIndex = 9;
+      this.generateBudgetsButton.Text = "Generate...";
+      this.generateBudgetsButton.UseVisualStyleBackColor = true;
+      this.generateBudgetsButton.Click += new System.EventHandler(this.generateBudgetsButton_Click);
+      // 
+      // byTableTabPage
+      // 
+      this.byTableTabPage.Controls.Add(this.ertTableView);
+      this.byTableTabPage.Location = new System.Drawing.Point(4, 22);
+      this.byTableTabPage.Name = "byTableTabPage";
+      this.byTableTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.byTableTabPage.Size = new System.Drawing.Size(646, 387);
+      this.byTableTabPage.TabIndex = 2;
+      this.byTableTabPage.Text = "Expected Runtime Tables";
+      this.byTableTabPage.UseVisualStyleBackColor = true;
+      // 
+      // ertTableView
+      // 
+      this.ertTableView.Caption = "StringConvertibleMatrix View";
+      this.ertTableView.Content = null;
+      this.ertTableView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.ertTableView.Location = new System.Drawing.Point(3, 3);
+      this.ertTableView.Name = "ertTableView";
+      this.ertTableView.ReadOnly = false;
+      this.ertTableView.ShowRowsAndColumnsTextBox = false;
+      this.ertTableView.ShowStatisticalInformation = false;
+      this.ertTableView.Size = new System.Drawing.Size(640, 381);
+      this.ertTableView.TabIndex = 0;
+      // 
+      // problemComboBox
+      // 
+      this.problemComboBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.problemComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
+      this.problemComboBox.FormattingEnabled = true;
+      this.problemComboBox.Location = new System.Drawing.Point(69, 30);
+      this.problemComboBox.Name = "problemComboBox";
+      this.problemComboBox.Size = new System.Drawing.Size(582, 21);
+      this.problemComboBox.TabIndex = 3;
+      this.problemComboBox.SelectedIndexChanged += new System.EventHandler(this.problemComboBox_SelectedIndexChanged);
+      // 
+      // problemLabel
+      // 
+      this.problemLabel.AutoSize = true;
+      this.problemLabel.Location = new System.Drawing.Point(3, 33);
+      this.problemLabel.Name = "problemLabel";
+      this.problemLabel.Size = new System.Drawing.Size(48, 13);
+      this.problemLabel.TabIndex = 2;
+      this.problemLabel.Text = "Problem:";
+      // 
+      // RunCollectionRLDView
+      // 
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+      this.Controls.Add(this.tabControl);
+      this.Controls.Add(this.groupComboBox);
+      this.Controls.Add(this.groupLabel);
+      this.Controls.Add(this.problemLabel);
+      this.Controls.Add(this.dataTableLabel);
+      this.Controls.Add(this.problemComboBox);
+      this.Controls.Add(this.dataTableComboBox);
+      this.Name = "RunCollectionRLDView";
+      this.Size = new System.Drawing.Size(654, 497);
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.tabControl.ResumeLayout(false);
+      this.byTargetTabPage.ResumeLayout(false);
+      this.byTargetTabPage.PerformLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.targetChart)).EndInit();
+      this.byCostTabPage.ResumeLayout(false);
+      this.byCostTabPage.PerformLayout();
+      this.byTableTabPage.ResumeLayout(false);
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.ComboBox dataTableComboBox;
+    private System.Windows.Forms.Label dataTableLabel;
+    private System.Windows.Forms.Label groupLabel;
+    private System.Windows.Forms.ComboBox groupComboBox;
+    private System.Windows.Forms.CheckBox targetLogScalingCheckBox;
+    private System.Windows.Forms.TextBox targetsTextBox;
+    private System.Windows.Forms.Label targetsLabel;
+    protected System.Windows.Forms.ErrorProvider errorProvider;
+    private System.Windows.Forms.Button addTargetsAsResultButton;
+    private System.Windows.Forms.Button generateTargetsButton;
+    private System.Windows.Forms.ToolTip toolTip;
+    private System.Windows.Forms.Button addBudgetsAsResultButton;
+    private System.Windows.Forms.TextBox budgetsTextBox;
+    private System.Windows.Forms.Label budgetsLabel;
+    private System.Windows.Forms.CheckBox aggregateTargetsCheckBox;
+    private System.Windows.Forms.TabControl tabControl;
+    private System.Windows.Forms.TabPage byTargetTabPage;
+    private System.Windows.Forms.TabPage byCostTabPage;
+    private System.Windows.Forms.TabPage byTableTabPage;
+    private System.Windows.Forms.CheckBox eachOrAllBudgetsCheckBox;
+    private System.Windows.Forms.Button generateBudgetsButton;
+    private System.Windows.Forms.CheckBox budgetLogScalingCheckBox;
+    private System.Windows.Forms.Label problemLabel;
+    private System.Windows.Forms.ComboBox problemComboBox;
+    private Data.Views.StringConvertibleMatrixView ertTableView;
+    private Visualization.ChartControlsExtensions.EnhancedChart targetChart;
+    private MainForm.WindowsForms.ViewHost byCostViewHost;
+    private System.Windows.Forms.CheckBox boundShadingCheckBox;
+  }
+}
Index: /trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs	(revision 14102)
+++ /trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs	(revision 14102)
@@ -0,0 +1,1161 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Globalization;
+using System.Linq;
+using System.Windows.Forms;
+using System.Windows.Forms.DataVisualization.Charting;
+using HeuristicLab.Analysis;
+using HeuristicLab.Collections;
+using HeuristicLab.Core.Views;
+using HeuristicLab.Data;
+using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
+
+namespace HeuristicLab.Optimization.Views {
+  [View("Run-length Distribution View")]
+  [Content(typeof(RunCollection), false)]
+  public partial class RunCollectionRLDView : ItemView {
+    private List<Series> invisibleTargetSeries;
+
+    private const string AllRuns = "All Runs";
+
+    private static readonly Color[] colors = new[] {
+      Color.FromArgb(0x40, 0x6A, 0xB7),
+      Color.FromArgb(0xB1, 0x6D, 0x01),
+      Color.FromArgb(0x4E, 0x8A, 0x06),
+      Color.FromArgb(0x75, 0x50, 0x7B),
+      Color.FromArgb(0x72, 0x9F, 0xCF),
+      Color.FromArgb(0xA4, 0x00, 0x00),
+      Color.FromArgb(0xAD, 0x7F, 0xA8),
+      Color.FromArgb(0x29, 0x50, 0xCF),
+      Color.FromArgb(0x90, 0xB0, 0x60),
+      Color.FromArgb(0xF5, 0x89, 0x30),
+      Color.FromArgb(0x55, 0x57, 0x53),
+      Color.FromArgb(0xEF, 0x59, 0x59),
+      Color.FromArgb(0xED, 0xD4, 0x30),
+      Color.FromArgb(0x63, 0xC2, 0x16),
+    };
+    private static readonly ChartDashStyle[] lineStyles = new[] {
+      ChartDashStyle.Solid,
+      ChartDashStyle.Dash,
+      ChartDashStyle.DashDot,
+      ChartDashStyle.Dot
+    };
+    private static readonly DataRowVisualProperties.DataRowLineStyle[] hlLineStyles = new[] {
+      DataRowVisualProperties.DataRowLineStyle.Solid,
+      DataRowVisualProperties.DataRowLineStyle.Dash,
+      DataRowVisualProperties.DataRowLineStyle.DashDot,
+      DataRowVisualProperties.DataRowLineStyle.Dot
+    };
+
+    public new RunCollection Content {
+      get { return (RunCollection)base.Content; }
+      set { base.Content = value; }
+    }
+
+    private double[] targets;
+    private double[] budgets;
+
+    private bool suppressUpdates;
+    private readonly IndexedDataTable<double> byCostDataTable;
+    public IndexedDataTable<double> ByCostDataTable {
+      get { return byCostDataTable; }
+    }
+
+    public RunCollectionRLDView() {
+      InitializeComponent();
+      invisibleTargetSeries = new List<Series>();
+
+      targetChart.CustomizeAllChartAreas();
+      targetChart.ChartAreas[0].CursorX.Interval = 1;
+      targetChart.SuppressExceptions = true;
+      byCostDataTable = new IndexedDataTable<double>("ECDF by Cost", "A data table containing the ECDF of each of a number of groups.") {
+        VisualProperties = {
+          YAxisTitle = "Proportion of unused budgets",
+          YAxisMinimumFixedValue = 0,
+          YAxisMinimumAuto = false,
+          YAxisMaximumFixedValue = 1,
+          YAxisMaximumAuto = false
+        }
+      };
+      byCostViewHost.Content = byCostDataTable;
+      suppressUpdates = false;
+    }
+
+    #region Content events
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.ItemsAdded += Content_ItemsAdded;
+      Content.ItemsRemoved += Content_ItemsRemoved;
+      Content.CollectionReset += Content_CollectionReset;
+      Content.UpdateOfRunsInProgressChanged += Content_UpdateOfRunsInProgressChanged;
+      Content.OptimizerNameChanged += Content_AlgorithmNameChanged;
+    }
+    protected override void DeregisterContentEvents() {
+      Content.ItemsAdded -= Content_ItemsAdded;
+      Content.ItemsRemoved -= Content_ItemsRemoved;
+      Content.CollectionReset -= Content_CollectionReset;
+      Content.UpdateOfRunsInProgressChanged -= Content_UpdateOfRunsInProgressChanged;
+      Content.OptimizerNameChanged -= Content_AlgorithmNameChanged;
+      base.DeregisterContentEvents();
+    }
+
+    private void Content_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IRun> e) {
+      if (suppressUpdates) return;
+      if (InvokeRequired) {
+        Invoke(new CollectionItemsChangedEventHandler<IRun>(Content_ItemsAdded), sender, e);
+        return;
+      }
+      UpdateGroupAndProblemComboBox();
+      UpdateDataTableComboBox();
+      foreach (var run in e.Items)
+        RegisterRunEvents(run);
+    }
+    private void Content_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IRun> e) {
+      if (suppressUpdates) return;
+      if (InvokeRequired) {
+        Invoke(new CollectionItemsChangedEventHandler<IRun>(Content_ItemsRemoved), sender, e);
+        return;
+      }
+      UpdateGroupAndProblemComboBox();
+      UpdateDataTableComboBox();
+      foreach (var run in e.Items)
+        DeregisterRunEvents(run);
+    }
+    private void Content_CollectionReset(object sender, CollectionItemsChangedEventArgs<IRun> e) {
+      if (suppressUpdates) return;
+      if (InvokeRequired) {
+        Invoke(new CollectionItemsChangedEventHandler<IRun>(Content_CollectionReset), sender, e);
+        return;
+      }
+      UpdateGroupAndProblemComboBox();
+      UpdateDataTableComboBox();
+      foreach (var run in e.OldItems)
+        DeregisterRunEvents(run);
+    }
+    private void Content_AlgorithmNameChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_AlgorithmNameChanged), sender, e);
+      else UpdateCaption();
+    }
+    private void Content_UpdateOfRunsInProgressChanged(object sender, EventArgs e) {
+      if (InvokeRequired) {
+        Invoke(new EventHandler(Content_UpdateOfRunsInProgressChanged), sender, e);
+        return;
+      }
+      suppressUpdates = Content.UpdateOfRunsInProgress;
+      if (!suppressUpdates) {
+        UpdateDataTableComboBox();
+        UpdateGroupAndProblemComboBox();
+        UpdateRuns();
+      }
+    }
+
+    private void RegisterRunEvents(IRun run) {
+      run.PropertyChanged += run_PropertyChanged;
+    }
+    private void DeregisterRunEvents(IRun run) {
+      run.PropertyChanged -= run_PropertyChanged;
+    }
+    private void run_PropertyChanged(object sender, PropertyChangedEventArgs e) {
+      if (suppressUpdates) return;
+      if (InvokeRequired) {
+        Invoke((Action<object, PropertyChangedEventArgs>)run_PropertyChanged, sender, e);
+      } else {
+        if (e.PropertyName == "Visible")
+          UpdateRuns();
+      }
+    }
+    #endregion
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      dataTableComboBox.Items.Clear();
+      groupComboBox.Items.Clear();
+      targetChart.ChartAreas[0].AxisX.IsLogarithmic = false;
+      targetChart.Series.Clear();
+      invisibleTargetSeries.Clear();
+      byCostDataTable.VisualProperties.XAxisLogScale = false;
+      byCostDataTable.Rows.Clear();
+
+      UpdateCaption();
+      if (Content != null) {
+        UpdateGroupAndProblemComboBox();
+        UpdateDataTableComboBox();
+      }
+    }
+
+
+    private void UpdateGroupAndProblemComboBox() {
+      var selectedGroupItem = (string)groupComboBox.SelectedItem;
+
+      var groupings = Content.ParameterNames.OrderBy(x => x).ToArray();
+      groupComboBox.Items.Clear();
+      groupComboBox.Items.Add(AllRuns);
+      groupComboBox.Items.AddRange(groupings);
+      if (selectedGroupItem != null && groupComboBox.Items.Contains(selectedGroupItem)) {
+        groupComboBox.SelectedItem = selectedGroupItem;
+      } else if (groupComboBox.Items.Count > 0) {
+        groupComboBox.SelectedItem = groupComboBox.Items[0];
+      }
+
+      var problems = new HashSet<ProblemDescription>();
+      foreach (var run in Content) {
+        problems.Add(new ProblemDescription(run));
+      }
+
+      var problemTypesDifferent = problems.Select(x => x.ProblemType).Where(x => !string.IsNullOrEmpty(x)).Distinct().Count() > 1;
+      var problemNamesDifferent = problems.Select(x => x.ProblemName).Where(x => !string.IsNullOrEmpty(x)).Distinct().Count() > 1;
+      var evaluatorDifferent = problems.Select(x => x.Evaluator).Where(x => !string.IsNullOrEmpty(x)).Distinct().Count() > 1;
+      var maximizationDifferent = problems.Select(x => x.Maximization).Distinct().Count() > 1;
+      var allEqual = !problemTypesDifferent && !problemNamesDifferent && !evaluatorDifferent && !maximizationDifferent;
+
+      var selectedProblemItem = (ProblemDescription)problemComboBox.SelectedItem;
+      problemComboBox.Items.Clear();
+      problemComboBox.Items.Add(ProblemDescription.MatchAll);
+      if (selectedProblemItem == null || selectedProblemItem == ProblemDescription.MatchAll)
+        problemComboBox.SelectedIndex = 0;
+      foreach (var prob in problems.OrderBy(x => x.ToString()).ToList()) {
+        prob.DisplayProblemType = problemTypesDifferent;
+        prob.DisplayProblemName = problemNamesDifferent || allEqual;
+        prob.DisplayEvaluator = evaluatorDifferent;
+        prob.DisplayMaximization = maximizationDifferent;
+        problemComboBox.Items.Add(prob);
+        if (prob.Equals(selectedProblemItem)) problemComboBox.SelectedItem = prob;
+      }
+      SetEnabledStateOfControls();
+    }
+
+    private void UpdateDataTableComboBox() {
+      string selectedItem = (string)dataTableComboBox.SelectedItem;
+
+      dataTableComboBox.Items.Clear();
+      var dataTables = (from run in Content
+                        from result in run.Results
+                        where result.Value is IndexedDataTable<double>
+                        select result.Key).Distinct().ToArray();
+
+      dataTableComboBox.Items.AddRange(dataTables);
+      if (selectedItem != null && dataTableComboBox.Items.Contains(selectedItem)) {
+        dataTableComboBox.SelectedItem = selectedItem;
+      } else if (dataTableComboBox.Items.Count > 0) {
+        dataTableComboBox.SelectedItem = dataTableComboBox.Items[0];
+      }
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      groupComboBox.Enabled = Content != null;
+      problemComboBox.Enabled = Content != null && problemComboBox.Items.Count > 1;
+      dataTableComboBox.Enabled = Content != null && dataTableComboBox.Items.Count > 1;
+      addTargetsAsResultButton.Enabled = Content != null && targets != null && dataTableComboBox.SelectedIndex >= 0;
+      addBudgetsAsResultButton.Enabled = Content != null && budgets != null && dataTableComboBox.SelectedIndex >= 0;
+    }
+
+    private Dictionary<string, Dictionary<ProblemDescription, Tuple<double, List<IRun>>>> GroupRuns() {
+      var groupedRuns = new Dictionary<string, Dictionary<ProblemDescription, Tuple<double, List<IRun>>>>();
+
+      var table = (string)dataTableComboBox.SelectedItem;
+      if (string.IsNullOrEmpty(table)) return groupedRuns;
+
+      var selectedGroup = (string)groupComboBox.SelectedItem;
+      if (string.IsNullOrEmpty(selectedGroup)) return groupedRuns;
+
+      var selectedProblem = (ProblemDescription)problemComboBox.SelectedItem;
+      if (selectedProblem == null) return groupedRuns;
+
+      var targetsPerProblem = CalculateBestTargetPerProblemInstance(table);
+
+      foreach (var x in (from r in Content
+                         where (selectedGroup == AllRuns || r.Parameters.ContainsKey(selectedGroup))
+                           && selectedProblem.Match(r)
+                           && r.Results.ContainsKey(table)
+                           && r.Visible
+                         group r by selectedGroup == AllRuns ? AllRuns : r.Parameters[selectedGroup].ToString() into g
+                         select Tuple.Create(g.Key, g.ToList()))) {
+        var pDict = new Dictionary<ProblemDescription, Tuple<double, List<IRun>>>();
+        foreach (var y in (from r in x.Item2
+                           let pd = new ProblemDescription(r)
+                           group r by pd into g
+                           select Tuple.Create(g.Key, g.ToList()))) {
+          pDict[y.Item1] = Tuple.Create(targetsPerProblem[y.Item1], y.Item2);
+        }
+        groupedRuns[x.Item1] = pDict;
+      }
+
+      return groupedRuns;
+    }
+
+    #region Performance analysis by (multiple) target(s)
+    private void UpdateResultsByTarget() {
+      // necessary to reset log scale -> empty chart cannot use log scaling
+      targetChart.ChartAreas[0].AxisX.IsLogarithmic = false;
+      targetChart.Series.Clear();
+      invisibleTargetSeries.Clear();
+
+      var table = (string)dataTableComboBox.SelectedItem;
+      if (string.IsNullOrEmpty(table)) return;
+
+      if (targets == null) GenerateDefaultTargets();
+
+      var groupedRuns = GroupRuns();
+      if (groupedRuns.Count == 0) return;
+
+      var xAxisTitles = new HashSet<string>();
+      var colorCount = 0;
+      var lineStyleCount = 0;
+
+      // if the group contains multiple different problem instances 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 maxEfforts = new Dictionary<ProblemDescription, double>();
+      double minEff = double.MaxValue, maxEff = double.MinValue;
+      foreach (var group in groupedRuns) {
+        foreach (var problem in group.Value) {
+          double problemSpecificMaxEff;
+          if (!maxEfforts.TryGetValue(problem.Key, out problemSpecificMaxEff)) {
+            problemSpecificMaxEff = 0;
+          }
+          var bestKnownTarget = problem.Value.Item1;
+          var max = problem.Key.IsMaximization();
+          var worstTarget = (max ? (1 - targets.Max()) : (1 + targets.Max())) * bestKnownTarget;
+          var bestTarget = (max ? (1 - targets.Min()) : (1 + targets.Min())) * bestKnownTarget;
+          foreach (var run in problem.Value.Item2) {
+            var row = ((IndexedDataTable<double>)run.Results[table]).Rows.First().Values;
+            var a = row.FirstOrDefault(x => max ? x.Item2 >= worstTarget : x.Item2 <= worstTarget);
+            var b = row.FirstOrDefault(x => max ? x.Item2 >= bestTarget : x.Item2 <= bestTarget);
+            var firstEff = (a == default(Tuple<double, double>)) ? row.Last().Item1 : a.Item1;
+            var lastEff = (b == default(Tuple<double, double>)) ? row.Last().Item1 : b.Item1;
+            if (minEff > firstEff) minEff = firstEff;
+            if (maxEff < lastEff) maxEff = lastEff;
+            if (problemSpecificMaxEff < lastEff) problemSpecificMaxEff = lastEff;
+          }
+          maxEfforts[problem.Key] = problemSpecificMaxEff;
+        }
+      }
+      maxEff = Math.Min(maxEff, maxEfforts.Values.Min());
+
+      var minZeros = (int)Math.Floor(Math.Log10(minEff));
+      var maxZeros = (int)Math.Floor(Math.Log10(maxEff));
+      var axisMin = (decimal)Math.Pow(10, minZeros);
+      var axisMax = (decimal)Math.Pow(10, maxZeros);
+      if (!targetLogScalingCheckBox.Checked) {
+        var minAdd = (decimal)Math.Pow(10, minZeros - 1) * 2;
+        var maxAdd = (decimal)Math.Pow(10, maxZeros - 1) * 2;
+        while (axisMin + minAdd < (decimal)minEff) axisMin += minAdd;
+        while (axisMax <= (decimal)maxEff) axisMax += maxAdd;
+      } else axisMax = (decimal)Math.Pow(10, (int)Math.Ceiling(Math.Log10(maxEff)));
+      targetChart.ChartAreas[0].AxisX.Minimum = (double)axisMin;
+      targetChart.ChartAreas[0].AxisX.Maximum = (double)axisMax;
+
+      foreach (var group in groupedRuns) {
+        // hits describes the number of target hits at a certain time for a certain group
+        var hits = new Dictionary<string, SortedList<double, int>>();
+        // misses describes the number of target misses after a certain time for a certain group
+        // for instance when a run ends, but has not achieved all targets, misses describes
+        // how many targets have been left open at the point when the run ended
+        var misses = new Dictionary<string, SortedList<double, int>>();
+        var maxLength = 0.0;
+
+        var noRuns = 0;
+        foreach (var problem in group.Value) {
+          foreach (var run in problem.Value.Item2) {
+            var resultsTable = (IndexedDataTable<double>)run.Results[table];
+            xAxisTitles.Add(resultsTable.VisualProperties.XAxisTitle);
+
+            if (aggregateTargetsCheckBox.Checked) {
+              var length = CalculateHitsForAllTargets(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, maxEff);
+              maxLength = Math.Max(length, maxLength);
+            } else {
+              CalculateHitsForEachTarget(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, maxEff);
+            }
+            noRuns++;
+          }
+        }
+        foreach (var list in hits) {
+          var row = new Series(list.Key) {
+            ChartType = SeriesChartType.StepLine,
+            BorderWidth = 2,
+            Color = colors[colorCount],
+            BorderDashStyle = lineStyles[lineStyleCount],
+          };
+          var rowShade = new Series(list.Key + "-range") {
+            IsVisibleInLegend = false,
+            ChartType = SeriesChartType.Range,
+            Color = Color.FromArgb(32, colors[colorCount])
+          };
+
+          var ecdf = 0.0;
+          var missedecdf = 0.0;
+          var iter = misses[list.Key].GetEnumerator();
+          var moreMisses = iter.MoveNext();
+          var totalTargets = noRuns;
+          if (aggregateTargetsCheckBox.Checked) totalTargets *= targets.Length;
+          var movingTargets = totalTargets;
+          foreach (var h in list.Value) {
+            while (moreMisses && iter.Current.Key <= h.Key) {
+              missedecdf += iter.Current.Value;
+              movingTargets -= iter.Current.Value;
+              if (row.Points.Count > 0 && row.Points.Last().XValue == iter.Current.Key)
+                row.Points.Last().SetValueY(ecdf / movingTargets);
+              else row.Points.AddXY(iter.Current.Key, ecdf / movingTargets);
+              if (boundShadingCheckBox.Checked) {
+                if (rowShade.Points.Count > 0 && rowShade.Points.Last().XValue == iter.Current.Key)
+                  rowShade.Points.Last().SetValueY(ecdf / totalTargets, (ecdf + missedecdf) / totalTargets);
+                else rowShade.Points.Add(new DataPoint(iter.Current.Key, new[] { ecdf / totalTargets, (ecdf + missedecdf) / totalTargets }));
+              }
+              moreMisses = iter.MoveNext();
+            }
+            ecdf += h.Value;
+            if (row.Points.Count > 0 && row.Points.Last().XValue == h.Key)
+              row.Points.Last().SetValueY(ecdf / movingTargets);
+            else row.Points.AddXY(h.Key, ecdf / movingTargets);
+            if (missedecdf > 0 && boundShadingCheckBox.Checked) {
+              if (rowShade.Points.Count > 0 && rowShade.Points.Last().XValue == h.Key)
+                rowShade.Points.Last().SetValueY(ecdf / totalTargets, (ecdf + missedecdf) / totalTargets);
+              else rowShade.Points.Add(new DataPoint(h.Key, new[] { ecdf / totalTargets, (ecdf + missedecdf) / totalTargets }));
+            }
+          }
+
+          while (moreMisses) {
+            // if there are misses beyond the last hit we extend the shaded area
+            missedecdf += iter.Current.Value;
+            //movingTargets -= iter.Current.Value;
+            if (row.Points.Count > 0 && row.Points.Last().XValue == iter.Current.Key)
+              row.Points.Last().SetValueY(ecdf / movingTargets);
+            else row.Points.AddXY(iter.Current.Key, ecdf / movingTargets);
+            if (boundShadingCheckBox.Checked) {
+              if (rowShade.Points.Count > 0 && rowShade.Points.Last().XValue == iter.Current.Key)
+                rowShade.Points.Last().SetValueY(ecdf / totalTargets, (ecdf + missedecdf) / totalTargets);
+              else rowShade.Points.Add(new DataPoint(iter.Current.Key, new[] { ecdf / totalTargets, (ecdf + missedecdf) / totalTargets }));
+            }
+            moreMisses = iter.MoveNext();
+          }
+
+          if (maxLength > 0 && (row.Points.Count == 0 || row.Points.Last().XValue < maxLength))
+            row.Points.AddXY(maxLength, ecdf / movingTargets);
+
+          if (row.Points.Count > 0) {
+            var point = row.Points.Last();
+            point.Label = row.Name;
+            point.MarkerStyle = MarkerStyle.Cross;
+            point.MarkerBorderWidth = 1;
+          }
+
+          ConfigureSeries(row);
+          targetChart.Series.Add(rowShade);
+          targetChart.Series.Add(row);
+        }
+        colorCount = (colorCount + 1) % colors.Length;
+        if (colorCount == 0) lineStyleCount = (lineStyleCount + 1) % lineStyles.Length;
+      }
+
+      if (targets.Length == 1)
+        targetChart.ChartAreas[0].AxisY.Title = "Probability to be " + (targets[0] * 100) + "% worse than best";
+      else targetChart.ChartAreas[0].AxisY.Title = "Proportion of reached targets";
+      targetChart.ChartAreas[0].AxisX.Title = string.Join(" / ", xAxisTitles);
+      targetChart.ChartAreas[0].AxisX.IsLogarithmic = CanDisplayLogarithmic();
+      targetChart.ChartAreas[0].CursorY.Interval = 0.05;
+      UpdateErtTables(groupedRuns);
+    }
+
+    private void GenerateDefaultTargets() {
+      targets = new[] { 0.1, 0.05, 0.02, 0.01, 0 };
+      suppressTargetsEvents = true;
+      targetsTextBox.Text = string.Join("% ; ", targets.Select(x => x * 100)) + "%";
+      suppressTargetsEvents = false;
+    }
+
+    private void CalculateHitsForEachTarget(Dictionary<string, SortedList<double, int>> hits,
+                                            Dictionary<string, SortedList<double, int>> misses,
+                                            IndexedDataRow<double> row, ProblemDescription problem,
+                                            string group, double bestTarget, double maxEffort) {
+      foreach (var t in targets.Select(x => Tuple.Create((problem.IsMaximization() ? (1 - x) : (1 + x)) * bestTarget, x))) {
+        var l = t.Item1;
+        var key = group + "_" + (t.Item2 * 100) + "%_" + l;
+        if (!hits.ContainsKey(key)) {
+          hits.Add(key, new SortedList<double, int>());
+          misses.Add(key, new SortedList<double, int>());
+        }
+        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))
+              hits[key][v.Item1]++;
+            else hits[key][v.Item1] = 1;
+            hit = true;
+            break;
+          }
+        }
+        if (!hit) {
+          var max = Math.Min(row.Values.Last().Item1, maxEffort);
+          if (misses[key].ContainsKey(max))
+            misses[key][max]++;
+          else misses[key][max] = 1;
+        }
+      }
+    }
+
+    private double CalculateHitsForAllTargets(Dictionary<string, SortedList<double, int>> hits,
+                                              Dictionary<string, SortedList<double, int>> misses,
+                                              IndexedDataRow<double> row, ProblemDescription problem,
+                                              string group, double bestTarget, double maxEffort) {
+      var values = row.Values;
+      if (!hits.ContainsKey(group)) {
+        hits.Add(group, new SortedList<double, int>());
+        misses.Add(group, new SortedList<double, int>());
+      }
+
+      var i = 0;
+      var j = 0;
+      while (i < targets.Length && j < values.Count) {
+        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) {
+          if (hits[group].ContainsKey(current.Item1)) hits[group][current.Item1]++;
+          else hits[group][current.Item1] = 1;
+          i++;
+        } else {
+          j++;
+        }
+      }
+      if (j == values.Count) j--;
+      var effort = Math.Min(values[j].Item1, maxEffort);
+      if (i < targets.Length) {
+        if (misses[group].ContainsKey(effort))
+          misses[group][effort] += targets.Length - i;
+        else misses[group][effort] = targets.Length - i;
+      }
+      return effort;
+    }
+
+    private void UpdateErtTables(Dictionary<string, Dictionary<ProblemDescription, Tuple<double, List<IRun>>>> groupedRuns) {
+      ertTableView.Content = null;
+      var columns = 1 + targets.Length + 1;
+      var matrix = new string[groupedRuns.Count * groupedRuns.Max(x => x.Value.Count) + groupedRuns.Max(x => x.Value.Count), columns];
+      var rowCount = 0;
+
+      var tableName = (string)dataTableComboBox.SelectedItem;
+      if (string.IsNullOrEmpty(tableName)) return;
+
+      var targetsPerProblem = CalculateBestTargetPerProblemInstance(tableName);
+
+      var colNames = new string[columns];
+      colNames[0] = colNames[colNames.Length - 1] = string.Empty;
+      for (var i = 0; i < targets.Length; i++) {
+        colNames[i + 1] = targets[i].ToString("0.0%");
+      }
+      var problems = groupedRuns.SelectMany(x => x.Value.Keys).Distinct().ToList();
+
+      foreach (var problem in problems) {
+        matrix[rowCount, 0] = problem.ToString();
+        for (var i = 0; i < targets.Length; i++) {
+          matrix[rowCount, i + 1] = (targetsPerProblem[problem] * (problem.IsMaximization() ? (1 - targets[i]) : (1 + targets[i]))).ToString(CultureInfo.CurrentCulture.NumberFormat);
+        }
+        matrix[rowCount, columns - 1] = "#succ";
+        rowCount++;
+
+        foreach (var group in groupedRuns) {
+          matrix[rowCount, 0] = group.Key;
+          if (!group.Value.ContainsKey(problem)) {
+            matrix[rowCount, columns - 1] = "N/A";
+            rowCount++;
+            continue;
+          }
+          var runs = group.Value[problem].Item2;
+          ErtCalculationResult result = default(ErtCalculationResult);
+          for (var i = 0; i < targets.Length; i++) {
+            result = ExpectedRuntimeHelper.CalculateErt(runs, tableName, (problem.IsMaximization() ? (1 - targets[i]) : (1 + targets[i])) * group.Value[problem].Item1, problem.IsMaximization());
+            matrix[rowCount, i + 1] = result.ToString();
+          }
+          matrix[rowCount, columns - 1] = targets.Length > 0 ? result.SuccessfulRuns + "/" + result.TotalRuns : "-";
+          rowCount++;
+        }
+      }
+      ertTableView.Content = new StringMatrix(matrix) { ColumnNames = colNames };
+      ertTableView.DataGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCells);
+    }
+    #endregion
+
+    #region Performance analysis by (multiple) budget(s)
+    private void UpdateResultsByCost() {
+      // necessary to reset log scale -> empty chart cannot use log scaling
+      byCostDataTable.VisualProperties.XAxisLogScale = false;
+      byCostDataTable.Rows.Clear();
+
+      var table = (string)dataTableComboBox.SelectedItem;
+      if (string.IsNullOrEmpty(table)) return;
+
+      if (budgets == null) GenerateDefaultBudgets(table);
+
+      var groupedRuns = GroupRuns();
+      if (groupedRuns.Count == 0) return;
+
+      var colorCount = 0;
+      var lineStyleCount = 0;
+
+      var targetsPerProblem = CalculateBestTargetPerProblemInstance((string)dataTableComboBox.SelectedItem);
+
+      foreach (var group in groupedRuns) {
+        var hits = new Dictionary<string, SortedList<double, double>>();
+
+        foreach (var problem in group.Value) {
+          foreach (var run in problem.Value.Item2) {
+            var resultsTable = (IndexedDataTable<double>)run.Results[table];
+
+            if (eachOrAllBudgetsCheckBox.Checked) {
+              CalculateHitsForEachBudget(hits, resultsTable.Rows.First(), group.Value.Count, problem.Key, group.Key, problem.Value.Item2.Count, targetsPerProblem[problem.Key]);
+            } else {
+              CalculateHitsForAllBudgets(hits, resultsTable.Rows.First(), group.Value.Count, problem.Key, group.Key, problem.Value.Item2.Count, targetsPerProblem[problem.Key]);
+            }
+          }
+        }
+
+        foreach (var list in hits) {
+          var row = new IndexedDataRow<double>(list.Key) {
+            VisualProperties = {
+              ChartType = DataRowVisualProperties.DataRowChartType.StepLine,
+              LineWidth = 2,
+              Color = colors[colorCount],
+              LineStyle = hlLineStyles[lineStyleCount],
+              StartIndexZero = false
+            }
+          };
+
+          var total = 0.0;
+          foreach (var h in list.Value) {
+            total += h.Value;
+            row.Values.Add(Tuple.Create(h.Key, total));
+          }
+
+          byCostDataTable.Rows.Add(row);
+        }
+        colorCount = (colorCount + 1) % colors.Length;
+        if (colorCount == 0) lineStyleCount = (lineStyleCount + 1) % lineStyles.Length;
+      }
+
+      byCostDataTable.VisualProperties.XAxisTitle = "Targets to Best-Known Ratio";
+      byCostDataTable.VisualProperties.XAxisLogScale = byCostDataTable.Rows.Count > 0 && budgetLogScalingCheckBox.Checked;
+    }
+
+    private void GenerateDefaultBudgets(string table) {
+      var runs = GroupRuns().SelectMany(x => x.Value.Values).SelectMany(x => x.Item2).ToList();
+      var min = runs.Select(x => ((IndexedDataTable<double>)x.Results[table]).Rows.First().Values.Select(y => y.Item1).Min()).Min();
+      var max = runs.Select(x => ((IndexedDataTable<double>)x.Results[table]).Rows.First().Values.Select(y => y.Item1).Max()).Max();
+
+      var maxMagnitude = (int)Math.Ceiling(Math.Log10(max));
+      var minMagnitude = (int)Math.Floor(Math.Log10(min));
+      if (maxMagnitude - minMagnitude >= 3) {
+        budgets = new double[maxMagnitude - minMagnitude];
+        for (var i = minMagnitude; i < maxMagnitude; i++) {
+          budgets[i - minMagnitude] = Math.Pow(10, i);
+        }
+      } else {
+        var range = max - min;
+        budgets = Enumerable.Range(0, 6).Select(x => min + (x / 5.0) * range).ToArray();
+      }
+      suppressBudgetsEvents = true;
+      budgetsTextBox.Text = string.Join(" ; ", budgets);
+      suppressBudgetsEvents = false;
+    }
+
+    private void CalculateHitsForEachBudget(Dictionary<string, SortedList<double, double>> hits, IndexedDataRow<double> row, int groupCount, ProblemDescription problem, string groupName, int problemCount, double bestTarget) {
+      foreach (var b in budgets) {
+        var key = groupName + "-" + b;
+        if (!hits.ContainsKey(key)) hits.Add(key, new SortedList<double, double>());
+        Tuple<double, double> prev = null;
+        foreach (var v in row.Values) {
+          if (v.Item1 >= b) {
+            // the budget may be too low to achieve any target
+            if (prev == null && v.Item1 != b) break;
+            var tgt = ((prev == null || v.Item1 == b) ? v.Item2 : prev.Item2);
+            tgt = problem.IsMaximization() ? bestTarget / tgt : tgt / bestTarget;
+            if (hits[key].ContainsKey(tgt))
+              hits[key][tgt] += 1.0 / (groupCount * problemCount);
+            else hits[key][tgt] = 1.0 / (groupCount * problemCount);
+            break;
+          }
+          prev = v;
+        }
+        if (hits[key].Count == 0) hits.Remove(key);
+      }
+    }
+
+    private void CalculateHitsForAllBudgets(Dictionary<string, SortedList<double, double>> hits, IndexedDataRow<double> row, int groupCount, ProblemDescription problem, string groupName, int problemCount, double bestTarget) {
+      var values = row.Values;
+      if (!hits.ContainsKey(groupName)) hits.Add(groupName, new SortedList<double, double>());
+
+      var i = 0;
+      var j = 0;
+      Tuple<double, double> prev = null;
+      while (i < budgets.Length && j < values.Count) {
+        var current = values[j];
+        if (current.Item1 >= budgets[i]) {
+          if (prev != null || current.Item1 == budgets[i]) {
+            var tgt = (prev == null || current.Item1 == budgets[i]) ? current.Item2 : prev.Item2;
+            tgt = problem.IsMaximization() ? bestTarget / tgt : tgt / bestTarget;
+            if (!hits[groupName].ContainsKey(tgt)) hits[groupName][tgt] = 0;
+            hits[groupName][tgt] += 1.0 / (groupCount * problemCount * budgets.Length);
+          }
+          i++;
+        } else {
+          j++;
+          prev = current;
+        }
+      }
+      var lastTgt = values.Last().Item2;
+      lastTgt = problem.IsMaximization() ? bestTarget / lastTgt : lastTgt / bestTarget;
+      if (i < budgets.Length && !hits[groupName].ContainsKey(lastTgt)) hits[groupName][lastTgt] = 0;
+      while (i < budgets.Length) {
+        hits[groupName][lastTgt] += 1.0 / (groupCount * problemCount * budgets.Length);
+        i++;
+      }
+    }
+    #endregion
+
+    private void UpdateCaption() {
+      Caption = Content != null ? Content.OptimizerName + " RLD View" : ViewAttribute.GetViewName(GetType());
+    }
+
+    private void groupComboBox_SelectedIndexChanged(object sender, EventArgs e) {
+      UpdateRuns();
+      SetEnabledStateOfControls();
+    }
+    private void problemComboBox_SelectedIndexChanged(object sender, EventArgs e) {
+      UpdateRuns();
+      SetEnabledStateOfControls();
+    }
+    private void dataTableComboBox_SelectedIndexChanged(object sender, EventArgs e) {
+      if (dataTableComboBox.SelectedIndex >= 0)
+        GenerateDefaultBudgets((string)dataTableComboBox.SelectedItem);
+      UpdateRuns();
+      SetEnabledStateOfControls();
+    }
+
+    private void logScalingCheckBox_CheckedChanged(object sender, EventArgs e) {
+      UpdateResultsByTarget();
+      byCostDataTable.VisualProperties.XAxisLogScale = byCostDataTable.Rows.Count > 0 && budgetLogScalingCheckBox.Checked;
+    }
+
+    private void boundShadingCheckBox_CheckedChanged(object sender, EventArgs e) {
+      UpdateResultsByTarget();
+    }
+
+    #region Event handlers for target analysis
+    private bool suppressTargetsEvents;
+    private void targetsTextBox_Validating(object sender, CancelEventArgs e) {
+      if (suppressTargetsEvents) return;
+      var targetStrings = targetsTextBox.Text.Split(new[] { '%', ';', '\t', ' ' }, StringSplitOptions.RemoveEmptyEntries);
+      var targetList = new List<decimal>();
+      foreach (var ts in targetStrings) {
+        decimal t;
+        if (!decimal.TryParse(ts, out t)) {
+          errorProvider.SetError(targetsTextBox, "Not all targets can be parsed: " + ts);
+          e.Cancel = true;
+          return;
+        }
+        targetList.Add(t / 100);
+      }
+      if (targetList.Count == 0) {
+        errorProvider.SetError(targetsTextBox, "Give at least one target value!");
+        e.Cancel = true;
+        return;
+      }
+      e.Cancel = false;
+      errorProvider.SetError(targetsTextBox, null);
+      targets = targetList.Select(x => (double)x).OrderByDescending(x => x).ToArray();
+      suppressTargetsEvents = true;
+      try { targetsTextBox.Text = string.Join("% ; ", targets.Select(x => x * 100)) + "%"; } finally { suppressTargetsEvents = false; }
+
+      UpdateResultsByTarget();
+      SetEnabledStateOfControls();
+    }
+
+    private void aggregateTargetsCheckBox_CheckedChanged(object sender, EventArgs e) {
+      SuspendRepaint();
+      try {
+        UpdateResultsByTarget();
+      } finally { ResumeRepaint(true); }
+    }
+
+    private void generateTargetsButton_Click(object sender, EventArgs e) {
+      decimal max = 1, min = 0, count = 10;
+      if (targets != null) {
+        max = (decimal)targets.Max();
+        min = (decimal)targets.Min();
+        count = targets.Length;
+      } else if (Content.Count > 0 && dataTableComboBox.SelectedIndex >= 0) {
+        var table = (string)dataTableComboBox.SelectedItem;
+        max = (decimal)Content.Where(x => x.Results.ContainsKey(table)).Select(x => ((IndexedDataTable<double>)x.Results[table]).Rows.First().Values.Max(y => y.Item2)).Max();
+        min = (decimal)Content.Where(x => x.Results.ContainsKey(table)).Select(x => ((IndexedDataTable<double>)x.Results[table]).Rows.First().Values.Min(y => y.Item2)).Min();
+        count = 6;
+      }
+      using (var dialog = new DefineArithmeticProgressionDialog(false, min, max, (max - min) / count)) {
+        if (dialog.ShowDialog() == DialogResult.OK) {
+          if (dialog.Values.Any()) {
+            targets = dialog.Values.Select(x => (double)x).ToArray();
+            suppressTargetsEvents = true;
+            targetsTextBox.Text = string.Join("% ; ", targets);
+            suppressTargetsEvents = false;
+
+            UpdateResultsByTarget();
+            SetEnabledStateOfControls();
+          }
+        }
+      }
+    }
+
+    private void addTargetsAsResultButton_Click(object sender, EventArgs e) {
+      var table = (string)dataTableComboBox.SelectedItem;
+
+      var targetsPerProblem = CalculateBestTargetPerProblemInstance(table);
+
+      foreach (var run in Content) {
+        if (!run.Results.ContainsKey(table)) continue;
+        var resultsTable = (IndexedDataTable<double>)run.Results[table];
+        var values = resultsTable.Rows.First().Values;
+        var i = 0;
+        var j = 0;
+        var pd = new ProblemDescription(run);
+        while (i < targets.Length && j < values.Count) {
+          var target = (pd.IsMaximization() ? (1 - targets[i]) : (1 + targets[i])) * targetsPerProblem[pd];
+          var current = values[j];
+          if (pd.IsMaximization() && current.Item2 >= target
+              || !pd.IsMaximization() && current.Item2 <= target) {
+            run.Results[table + ".Target" + target] = new DoubleValue(current.Item1);
+            i++;
+          } else {
+            j++;
+          }
+        }
+      }
+    }
+    #endregion
+
+    #region Event handlers for cost analysis
+    private bool suppressBudgetsEvents;
+    private void budgetsTextBox_Validating(object sender, CancelEventArgs e) {
+      if (suppressBudgetsEvents) return;
+      var budgetStrings = budgetsTextBox.Text.Split(new[] { ';', '\t', ' ' }, StringSplitOptions.RemoveEmptyEntries);
+      var budgetList = new List<double>();
+      foreach (var ts in budgetStrings) {
+        double b;
+        if (!double.TryParse(ts, out b)) {
+          errorProvider.SetError(budgetsTextBox, "Not all targets can be parsed: " + ts);
+          e.Cancel = true;
+          return;
+        }
+        budgetList.Add(b);
+      }
+      if (budgetList.Count == 0) {
+        errorProvider.SetError(budgetsTextBox, "Give at least one target value!");
+        e.Cancel = true;
+        return;
+      }
+      e.Cancel = false;
+      errorProvider.SetError(budgetsTextBox, null);
+      budgets = budgetList.ToArray();
+      UpdateResultsByCost();
+      SetEnabledStateOfControls();
+    }
+
+    private void eachOrAllBudgetsCheckBox_CheckedChanged(object sender, EventArgs e) {
+      var each = eachOrAllBudgetsCheckBox.Checked;
+      eachOrAllBudgetsCheckBox.Text = each ? "each" : "all";
+      SuspendRepaint();
+      try {
+        UpdateResultsByCost();
+      } finally { ResumeRepaint(true); }
+    }
+
+    private void generateBudgetsButton_Click(object sender, EventArgs e) {
+      decimal max = 1, min = 0, count = 10;
+      if (budgets != null) {
+        max = (decimal)budgets.Max();
+        min = (decimal)budgets.Min();
+        count = budgets.Length;
+      } else if (Content.Count > 0 && dataTableComboBox.SelectedIndex >= 0) {
+        var table = (string)dataTableComboBox.SelectedItem;
+        min = (decimal)Content.Where(x => x.Results.ContainsKey(table)).Select(x => ((IndexedDataTable<double>)x.Results[table]).Rows.First().Values.Min(y => y.Item1)).Min();
+        max = (decimal)Content.Where(x => x.Results.ContainsKey(table)).Select(x => ((IndexedDataTable<double>)x.Results[table]).Rows.First().Values.Max(y => y.Item1)).Max();
+        count = 6;
+      }
+      using (var dialog = new DefineArithmeticProgressionDialog(false, min, max, (max - min) / count)) {
+        if (dialog.ShowDialog() == DialogResult.OK) {
+          if (dialog.Values.Any()) {
+            budgets = dialog.Values.OrderBy(x => x).Select(x => (double)x).ToArray();
+
+            suppressBudgetsEvents = true;
+            budgetsTextBox.Text = string.Join(" ; ", budgets);
+            suppressBudgetsEvents = false;
+
+            UpdateResultsByCost();
+            SetEnabledStateOfControls();
+          }
+        }
+      }
+    }
+
+    private void addBudgetsAsResultButton_Click(object sender, EventArgs e) {
+      var table = (string)dataTableComboBox.SelectedItem;
+      var budgetStrings = budgetsTextBox.Text.Split(new[] { ';', '\t', ' ' }, StringSplitOptions.RemoveEmptyEntries);
+      if (budgetStrings.Length == 0) {
+        MessageBox.Show("Define a number of budgets.");
+        return;
+      }
+      var budgetList = new List<double>();
+      foreach (var bs in budgetStrings) {
+        double v;
+        if (!double.TryParse(bs, out v)) {
+          MessageBox.Show("Budgets must be a valid number: " + bs);
+          return;
+        }
+        budgetList.Add(v);
+      }
+      budgetList.Sort();
+
+      foreach (var run in Content) {
+        if (!run.Results.ContainsKey(table)) continue;
+        var resultsTable = (IndexedDataTable<double>)run.Results[table];
+        var values = resultsTable.Rows.First().Values;
+        var i = 0;
+        var j = 0;
+        Tuple<double, double> prev = null;
+        while (i < budgetList.Count && j < values.Count) {
+          var current = values[j];
+          if (current.Item1 >= budgetList[i]) {
+            if (prev != null || current.Item1 == budgetList[i]) {
+              var tgt = (prev == null || current.Item1 == budgetList[i]) ? current.Item2 : prev.Item2;
+              run.Results[table + ".Cost" + budgetList[i]] = new DoubleValue(tgt);
+            }
+            i++;
+          } else {
+            j++;
+            prev = current;
+          }
+        }
+      }
+    }
+    #endregion
+
+    #region Helpers
+    private Dictionary<ProblemDescription, double> CalculateBestTargetPerProblemInstance(string table) {
+      return (from r in Content
+              where r.Visible
+              let pd = new ProblemDescription(r)
+              let target = r.Parameters.ContainsKey("BestKnownQuality")
+                           && r.Parameters["BestKnownQuality"] is DoubleValue
+                ? ((DoubleValue)r.Parameters["BestKnownQuality"]).Value
+                : ((IndexedDataTable<double>)r.Results[table]).Rows.First().Values.Last().Item2
+              group target by pd into g
+              select new { Problem = g.Key, Target = g.Key.IsMaximization() ? g.Max() : g.Min() })
+        .ToDictionary(x => x.Problem, x => x.Target);
+    }
+
+    private void UpdateRuns() {
+      if (InvokeRequired) {
+        Invoke((Action)UpdateRuns);
+        return;
+      }
+      SuspendRepaint();
+      try {
+        UpdateResultsByTarget();
+        UpdateResultsByCost();
+      } finally { ResumeRepaint(true); }
+    }
+    #endregion
+
+    private void ConfigureSeries(Series series) {
+      series.SmartLabelStyle.Enabled = true;
+      series.SmartLabelStyle.AllowOutsidePlotArea = LabelOutsidePlotAreaStyle.No;
+      series.SmartLabelStyle.CalloutLineAnchorCapStyle = LineAnchorCapStyle.None;
+      series.SmartLabelStyle.CalloutLineColor = series.Color;
+      series.SmartLabelStyle.CalloutLineWidth = 2;
+      series.SmartLabelStyle.CalloutStyle = LabelCalloutStyle.Underlined;
+      series.SmartLabelStyle.IsOverlappedHidden = false;
+      series.SmartLabelStyle.MaxMovingDistance = 200;
+      series.ToolTip = series.LegendText + " X = #VALX, Y = #VALY";
+    }
+
+    private void chart_MouseDown(object sender, MouseEventArgs e) {
+      HitTestResult result = targetChart.HitTest(e.X, e.Y);
+      if (result.ChartElementType == ChartElementType.LegendItem) {
+        ToggleTargetChartSeriesVisible(result.Series);
+      }
+    }
+    private void chart_MouseMove(object sender, MouseEventArgs e) {
+      HitTestResult result = targetChart.HitTest(e.X, e.Y);
+      if (result.ChartElementType == ChartElementType.LegendItem)
+        this.Cursor = Cursors.Hand;
+      else
+        this.Cursor = Cursors.Default;
+    }
+    private void chart_CustomizeLegend(object sender, CustomizeLegendEventArgs e) {
+      foreach (LegendItem legendItem in e.LegendItems) {
+        var series = targetChart.Series[legendItem.SeriesName];
+        if (series != null) {
+          bool seriesIsInvisible = invisibleTargetSeries.Any(x => x.Name == series.Name);
+          foreach (LegendCell cell in legendItem.Cells) {
+            cell.ForeColor = seriesIsInvisible ? Color.Gray : Color.Black;
+          }
+        }
+      }
+    }
+
+    private void ToggleTargetChartSeriesVisible(Series series) {
+      var indexList = invisibleTargetSeries.FindIndex(x => x.Name == series.Name);
+      var indexChart = targetChart.Series.IndexOf(series);
+      if (targetChart.Series.Count == 1) targetChart.ChartAreas[0].AxisX.IsLogarithmic = false;
+      targetChart.Series.RemoveAt(indexChart);
+      var s = indexList >= 0 ? invisibleTargetSeries[indexList] : new Series(series.Name) {
+        Color = series.Color,
+        ChartType = series.ChartType,
+        BorderWidth = series.BorderWidth,
+        BorderDashStyle = series.BorderDashStyle
+      };
+      if (indexList < 0) {
+        // hide
+        invisibleTargetSeries.Add(series);
+        var shadeSeries = targetChart.Series.FirstOrDefault(x => x.Name == series.Name + "-range");
+        if (shadeSeries != null) {
+          if (targetChart.Series.Count == 1) targetChart.ChartAreas[0].AxisX.IsLogarithmic = false;
+          targetChart.Series.Remove(shadeSeries);
+          invisibleTargetSeries.Add(shadeSeries);
+          indexChart--;
+        }
+      } else {
+        // show
+        invisibleTargetSeries.RemoveAt(indexList);
+        var shadeSeries = invisibleTargetSeries.FirstOrDefault(x => x.Name == series.Name + "-range");
+        if (shadeSeries != null) {
+          invisibleTargetSeries.Remove(shadeSeries);
+          InsertOrAddSeries(indexChart, shadeSeries);
+          indexChart++;
+        }
+      }
+      InsertOrAddSeries(indexChart, s);
+      targetChart.ChartAreas[0].AxisX.IsLogarithmic = CanDisplayLogarithmic();
+    }
+
+    private bool CanDisplayLogarithmic() {
+      return targetLogScalingCheckBox.Checked
+        && targetChart.Series.Count > 0 // must have a series
+        && targetChart.Series.Any(x => x.Points.Count > 0) // at least one series must have points
+        && targetChart.Series.All(s => s.Points.All(p => p.XValue > 0)); // all points must be positive
+    }
+
+    private void InsertOrAddSeries(int index, Series s) {
+      if (targetChart.Series.Count <= index)
+        targetChart.Series.Add(s);
+      else targetChart.Series.Insert(index, s);
+    }
+
+    private class ProblemDescription {
+      private readonly bool matchAll;
+      public static readonly ProblemDescription MatchAll = new ProblemDescription() {
+        ProblemName = "All with Best-Known"
+      };
+
+      private ProblemDescription() {
+        ProblemType = string.Empty;
+        ProblemName = string.Empty;
+        Evaluator = string.Empty;
+        Maximization = string.Empty;
+        DisplayProblemType = false;
+        DisplayProblemName = false;
+        DisplayEvaluator = false;
+        DisplayMaximization = false;
+        matchAll = true;
+      }
+
+      public ProblemDescription(IRun run) {
+        ProblemType = GetStringValueOrEmpty(run, "Problem Type");
+        ProblemName = GetStringValueOrEmpty(run, "Problem Name");
+        Evaluator = GetStringValueOrEmpty(run, "Evaluator");
+        Maximization = GetMaximizationValueOrEmpty(run, "Maximization");
+        DisplayProblemType = !string.IsNullOrEmpty(ProblemType);
+        DisplayProblemName = !string.IsNullOrEmpty(ProblemName);
+        DisplayEvaluator = !string.IsNullOrEmpty(Evaluator);
+        DisplayMaximization = !string.IsNullOrEmpty(Maximization);
+        matchAll = false;
+      }
+
+      public bool DisplayProblemType { get; set; }
+      public string ProblemType { get; set; }
+      public bool DisplayProblemName { get; set; }
+      public string ProblemName { get; set; }
+      public bool DisplayEvaluator { get; set; }
+      public string Evaluator { get; set; }
+      public bool DisplayMaximization { get; set; }
+      public string Maximization { get; set; }
+
+      public bool IsMaximization() {
+        return Maximization == "MAX";
+      }
+
+      public bool Match(IRun run) {
+        return matchAll ||
+               GetStringValueOrEmpty(run, "Problem Type") == ProblemType
+               && GetStringValueOrEmpty(run, "Problem Name") == ProblemName
+               && GetStringValueOrEmpty(run, "Evaluator") == Evaluator
+               && GetMaximizationValueOrEmpty(run, "Maximization") == Maximization;
+      }
+
+      private string GetStringValueOrEmpty(IRun run, string key) {
+        return run.Parameters.ContainsKey(key) ? ((StringValue)run.Parameters[key]).Value : string.Empty;
+      }
+
+      private string GetMaximizationValueOrEmpty(IRun run, string key) {
+        return run.Parameters.ContainsKey(key) ? (((BoolValue)run.Parameters[key]).Value ? "MAX" : "MIN") : string.Empty;
+      }
+
+      public override bool Equals(object obj) {
+        var other = obj as ProblemDescription;
+        if (other == null) return false;
+        return ProblemType == other.ProblemType
+               && ProblemName == other.ProblemName
+               && Evaluator == other.Evaluator
+               && Maximization == other.Maximization;
+      }
+
+      public override int GetHashCode() {
+        return ProblemType.GetHashCode() ^ ProblemName.GetHashCode() ^ Evaluator.GetHashCode() ^ Maximization.GetHashCode();
+      }
+
+      public override string ToString() {
+        return string.Join("  --  ", new[] {
+          (DisplayProblemType ? ProblemType : string.Empty),
+          (DisplayProblemName ? ProblemName : string.Empty),
+          (DisplayEvaluator ? Evaluator : string.Empty),
+          (DisplayMaximization ? Maximization : string.Empty)}.Where(x => !string.IsNullOrEmpty(x)));
+      }
+    }
+  }
+}
