Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/HeuristicLab.DataPreprocessing-3.3.csproj
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/HeuristicLab.DataPreprocessing-3.3.csproj	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/HeuristicLab.DataPreprocessing-3.3.csproj	(revision 10367)
@@ -219,4 +219,9 @@
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Views\StatisticsView.resx">
+      <DependentUpon>StatisticsView.cs</DependentUpon>
+    </EmbeddedResource>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/DataGridLogic.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/DataGridLogic.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/DataGridLogic.cs	(revision 10367)
@@ -32,4 +32,15 @@
     }
 
+    public string GetColumnTypeAsString(int columnIndex) {
+      if (preprocessingData.IsType<double>(columnIndex)) {
+        return "double";
+      } else if (preprocessingData.IsType<string>(columnIndex)) {
+        return "string";
+      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+        return "DateTime";
+      }
+      return "Unknown Type";
+    }
+
     public IEnumerable<string> RowNames {
       get {
@@ -43,6 +54,5 @@
       }
       bool valid = false;
-      string variableName = preprocessingData.GetVariableName(columnIndex);
-      if (preprocessingData.IsType<double>(variableName)) {
+      if (preprocessingData.IsType<double>(columnIndex)) {
         double val;
         valid = double.TryParse(value, out val);
@@ -51,5 +61,5 @@
           errorMessage = "Invalid Value (Valid Value Format: \"" + FormatPatterns.GetDoubleFormatPattern() + "\")";
         }
-      } else if (preprocessingData.IsType<string>(variableName)) {
+      } else if (preprocessingData.IsType<string>(columnIndex)) {
         valid = value != null;
         errorMessage = string.Empty;
@@ -57,5 +67,5 @@
           errorMessage = "Invalid Value (string must not be null)";
         }
-      } else if (preprocessingData.IsType<DateTime>(variableName)) {
+      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
         DateTime date;
         valid = DateTime.TryParse(value, out date);
@@ -65,5 +75,5 @@
         }
       } else {
-        throw new ArgumentException("column with variableName: " + variableName + " contains a non supported type.");
+        throw new ArgumentException("column " + columnIndex + " contains a non supported type.");
       }
 
@@ -72,29 +82,28 @@
 
     public string GetValue(int rowIndex, int columnIndex) {
-      return preprocessingData.GetCellAsString(preprocessingData.GetVariableName(columnIndex), rowIndex);
+      return preprocessingData.GetCellAsString(columnIndex, rowIndex);
     }
 
     public bool SetValue(string value, int rowIndex, int columnIndex) {
-      string variableName = preprocessingData.GetVariableName(columnIndex);
       bool valid = false;
-      if (preprocessingData.IsType<double>(variableName)) {
+      if (preprocessingData.IsType<double>(columnIndex)) {
         double val;
         valid = double.TryParse(value, out val);
         if (valid) {
-          preprocessingData.SetCell<double>(variableName, rowIndex, val);
+          preprocessingData.SetCell<double>(columnIndex, rowIndex, val);
         }
-      } else if (preprocessingData.IsType<string>(variableName)) {
+      } else if (preprocessingData.IsType<string>(columnIndex)) {
         valid = value != null;
         if (valid) {
-          preprocessingData.SetCell<string>(variableName, rowIndex, value);
+          preprocessingData.SetCell<string>(columnIndex, rowIndex, value);
         }
-      } else if (preprocessingData.IsType<DateTime>(variableName)) {
+      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
         DateTime date;
         valid = DateTime.TryParse(value, out date);
         if (valid) {
-          preprocessingData.SetCell<DateTime>(variableName, rowIndex, date);
+          preprocessingData.SetCell<DateTime>(columnIndex, rowIndex, date);
         }
       } else {
-        throw new ArgumentException("column with variableName: " + variableName + " contains a non supported type.");
+        throw new ArgumentException("column " + columnIndex + " contains a non supported type.");
       }
 
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingData.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingData.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingData.cs	(revision 10367)
@@ -33,9 +33,7 @@
   public class PreprocessingData : NamedItem, IPreprocessingData {
 
-    private IDictionary<string, IList> variableValues;
+    private IDictionary<int, IList> variableValues;
 
     private IList<string> variableNames;
-
-    private IDictionary<string, int> variableNameIndices;
 
     private double trainingToTestRatio;
@@ -43,6 +41,5 @@
     private PreprocessingData(PreprocessingData original, Cloner cloner)
       : base(original, cloner) {
-      variableValues = new Dictionary<string, IList>(variableValues);
-      variableNameIndices = new Dictionary<string, int>(variableNameIndices);
+      variableValues = new Dictionary<int, IList>(original.variableValues);
     }
 
@@ -53,22 +50,18 @@
       variableNames = new List<string>(problemData.Dataset.VariableNames);
       // create dictionary from variable name to index
-      variableNameIndices = new Dictionary<string, int>();
-      var variableNamesList = problemData.Dataset.VariableNames.ToList();
-      for (int i = 0; i < variableNamesList.Count; i++) {
-        variableNameIndices.Add(variableNamesList[i], i);
-      }
-
-      // copy values
-      variableValues = new Dictionary<string, IList>();
+
+      int columnIndex = 0;
+      variableValues = new Dictionary<int, IList>();
       foreach (var variableName in problemData.Dataset.VariableNames) {
         if (problemData.Dataset.IsType<double>(variableName)) {
-          variableValues[variableName] = problemData.Dataset.GetDoubleValues(variableName).ToList();
+          variableValues[columnIndex] = problemData.Dataset.GetDoubleValues(variableName).ToList();
         } else if (problemData.Dataset.IsType<string>(variableName)) {
-          variableValues[variableName] = CreateColumn<string>(problemData.Dataset, variableNameIndices[variableName], x => x);
+          variableValues[columnIndex] = CreateColumn<string>(problemData.Dataset, columnIndex, x => x);
         } else if (problemData.Dataset.IsType<DateTime>(variableName)) {
-          variableValues[variableName] = CreateColumn<DateTime>(problemData.Dataset, variableNameIndices[variableName], x => DateTime.Parse(x));
+          variableValues[columnIndex] = CreateColumn<DateTime>(problemData.Dataset, columnIndex, x => DateTime.Parse(x));
         } else {
           throw new ArgumentException("The datatype of column " + variableName + " must be of type List<double>, List<string> or List<DateTime>");
         }
+        ++columnIndex;
       }
 
@@ -79,5 +72,5 @@
       var list = new List<T>(ds.Rows);
       for (int row = 0; row < ds.Rows; ++row) {
-        list.Add(selector(ds.GetValue(row, column))); 
+        list.Add(selector(ds.GetValue(row, column)));
       }
       return list;
@@ -94,26 +87,51 @@
     #region IPreprocessingData Members
 
-    public T GetCell<T>(string variableName, int row) {
-      return (T)variableValues[variableName][row];
-    }
-
-    public void SetCell<T>(string variableName, int row, T value) {
-      variableValues[variableName][row] = value;
-    }
-
-    public string GetCellAsString(string variableName, int row) {
-      return variableValues[variableName][row].ToString();
-    }
-
+    [Obsolete("use the index based variant, is faster")]
+    public T GetCell<T>(string variableName, int rowIndex) {
+      return GetCell<T>(GetColumnIndex(variableName), rowIndex);
+    }
+
+    public T GetCell<T>(int columnIndex, int rowIndex) {
+      return (T)variableValues[columnIndex][rowIndex];
+    }
+
+    [Obsolete("use the index based variant, is faster")]
+    public void SetCell<T>(string variableName, int rowIndex, T value) {
+      SetCell<T>(GetColumnIndex(variableName), rowIndex, value);
+    }
+
+    public void SetCell<T>(int columnIndex, int rowIndex, T value) {
+      variableValues[columnIndex][rowIndex] = value;
+    }
+
+    [Obsolete("use the index based variant, is faster")]
+    public string GetCellAsString(string variableName, int rowIndex) {
+      return GetCellAsString(GetColumnIndex(variableName), rowIndex);
+    }
+
+    public string GetCellAsString(int columnIndex, int rowIndex) {
+      return variableValues[columnIndex][rowIndex].ToString();
+
+    }
+
+    [Obsolete("use the index based variant, is faster")]
     public IList<T> GetValues<T>(string variableName) {
-      // TODO: test if cast is valid
-      return (IList<T>) variableValues[variableName];
-    }
-
+      return GetValues<T>(GetColumnIndex(variableName));
+    }
+
+    public IList<T> GetValues<T>(int columnIndex) {
+      return (IList<T>)variableValues[columnIndex];
+    }
+
+    [Obsolete("use the index based variant, is faster")]
     public void SetValues<T>(string variableName, IList<T> values) {
-      if(IsType<T>(variableName)){
-        variableValues[variableName] = (IList) values;
-      }else{
-        throw new ArgumentException("The datatype of column " + variableName + " must be of type " + variableValues[variableName].GetType().Name + " but was " + typeof(T).Name);
+      SetValues<T>(GetColumnIndex(variableName), values);
+
+    }
+    public void SetValues<T>(int columnIndex, IList<T> values) {
+      if (IsType<T>(columnIndex)) {
+        variableValues[columnIndex] = (IList)values;
+      } else {
+        throw new ArgumentException("The datatype of column " + columnIndex + " must be of type " + variableValues[columnIndex].GetType().Name + " but was " + typeof(T).Name);
       }
     }
@@ -134,13 +152,16 @@
 
     public void InsertColumn<T>(string variableName, int columnIndex) {
-      variableValues.Add(variableName, new List<T>(Rows));
-      variableNameIndices.Add(variableName, columnIndex);
+      variableValues.Add(columnIndex, new List<T>(Rows));
       variableNames.Insert(columnIndex, variableName);
     }
 
+    public void DeleteColumn(int columnIndex) {
+      variableValues.Remove(columnIndex);
+      variableNames.RemoveAt(columnIndex);
+    }
+
+    [Obsolete("use the index based variant, is faster")]
     public void DeleteColumn(string variableName) {
-      variableValues.Remove(variableName);
-      variableNames.RemoveAt(variableNameIndices[variableName]);
-      variableNameIndices.Remove(variableName);
+      DeleteColumn(GetColumnIndex(variableName));
     }
 
@@ -157,10 +178,19 @@
     }
 
+    [Obsolete("use the index based variant, is faster")]
     public string GetVariableName(int columnIndex) {
       return variableNames[columnIndex];
     }
-
+    public int GetColumnIndex(string variableName) {
+      return variableNames.IndexOf(variableName);
+    }
+
+    [Obsolete("use the index based variant, is faster")]
     public bool IsType<T>(string variableName) {
-      return variableValues[variableName] is List<T>;
+      return IsType<T>(GetColumnIndex(variableName));
+
+    }
+    public bool IsType<T>(int columnIndex) {
+      return variableValues[columnIndex] is List<T>;
     }
 
@@ -170,11 +200,12 @@
 
     public int Rows {
-      get { return variableValues[variableNames[0]].Count; }
+      get { return variableValues.Count > 0 ? variableValues[0].Count : 0; }
     }
 
     public Dataset ExportToDataset() {
       IList<IList> values = new List<IList>();
-      foreach (var variable in VariableNames) {
-        values.Add(variableValues[variable]);
+
+      for (int i = 0; i < Columns; ++i) {
+        values.Add(variableValues[i]);
       }
 
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingDataManipulation.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingDataManipulation.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingDataManipulation.cs	(revision 10367)
@@ -3,5 +3,4 @@
 using System.Linq;
 using HeuristicLab.Data;
-using System.Collections;
 
 namespace HeuristicLab.DataPreprocessing {
@@ -17,39 +16,39 @@
     }
 
-    public void ReplaceIndicesByValue<T>(string variableName, IEnumerable<int> indices, T value) {
-      foreach (int index in indices) {
-        preprocessingData.SetCell<T>(variableName, index, value);
+    public void ReplaceIndicesByValue<T>(int columnIndex, IEnumerable<int> rowIndices, T value) {
+      foreach (int index in rowIndices) {
+        preprocessingData.SetCell<T>(columnIndex, index, value);
       }
     }
 
-    public void ReplaceIndicesByAverageValue(string variableName, IEnumerable<int> indices) {
-      double average = statisticInfo.GetAverage(variableName);
-      ReplaceIndicesByValue<double>(variableName, indices, average);
+    public void ReplaceIndicesByAverageValue(int columnIndex, IEnumerable<int> rowIndices) {
+      double average = statisticInfo.GetAverage(columnIndex);
+      ReplaceIndicesByValue<double>(columnIndex, rowIndices, average);
     }
 
-    public void ReplaceIndicesByMedianValue(string variableName, IEnumerable<int> indices) {
-      double median = statisticInfo.GetMedian(variableName);
-      ReplaceIndicesByValue<double>(variableName, indices, median);
+    public void ReplaceIndicesByMedianValue(int columnIndex, IEnumerable<int> rowIndices) {
+      double median = statisticInfo.GetMedian(columnIndex);
+      ReplaceIndicesByValue<double>(columnIndex, rowIndices, median);
     }
 
-    public void ReplaceIndicesByRandomValue(string variableName, IEnumerable<int> indices) {
+    public void ReplaceIndicesByRandomValue(int columnIndex, IEnumerable<int> rowIndices) {
       Random r = new Random();
 
-      double max = statisticInfo.GetMax<double>(variableName);
-      double min = statisticInfo.GetMin<double>(variableName);
+      double max = statisticInfo.GetMax<double>(columnIndex);
+      double min = statisticInfo.GetMin<double>(columnIndex);
       double randMultiplier = (max - min);
-      foreach (int index in indices) {
+      foreach (int index in rowIndices) {
         double rand = r.NextDouble() * randMultiplier + min;
-        preprocessingData.SetCell<double>(variableName, index, rand);
+        preprocessingData.SetCell<double>(columnIndex, index, rand);
       }
     }
 
-    public void ReplaceIndicesByLinearInterpolationOfNeighbours(string variableName, IEnumerable<int> indices) {
-      int countValues = preprocessingData.GetValues<double>(variableName).Count();
-      foreach (int index in indices) {
+    public void ReplaceIndicesByLinearInterpolationOfNeighbours(int columnIndex, IEnumerable<int> rowIndices) {
+      int countValues = preprocessingData.GetValues<double>(columnIndex).Count();
+      foreach (int index in rowIndices) {
         // dont replace first or last values
         if (index > 0 && index < countValues) {
-          int prevIndex = indexOfPrevPresentValue(variableName, index);
-          int nextIndex = indexOfNextPresentValue(variableName, index);
+          int prevIndex = indexOfPrevPresentValue(columnIndex, index);
+          int nextIndex = indexOfNextPresentValue(columnIndex, index);
 
           // no neighbours found
@@ -57,6 +56,6 @@
             continue;
           }
-          double prev = preprocessingData.GetCell<double>(variableName, prevIndex);
-          double next = preprocessingData.GetCell<double>(variableName, nextIndex);
+          double prev = preprocessingData.GetCell<double>(columnIndex, prevIndex);
+          double next = preprocessingData.GetCell<double>(columnIndex, nextIndex);
 
           int valuesToInterpolate = nextIndex - prevIndex;
@@ -66,5 +65,5 @@
           for (int i = prevIndex; i < nextIndex; ++i) {
             double interpolated = prev + (interpolationStep * (i - prevIndex));
-            preprocessingData.SetCell<double>(variableName, i, interpolated);
+            preprocessingData.SetCell<double>(columnIndex, i, interpolated);
           }
         }
@@ -72,7 +71,7 @@
     }
 
-    private int indexOfPrevPresentValue(string variableName, int start) {
+    private int indexOfPrevPresentValue(int columnIndex, int start) {
       int offset = start - 1;
-      while (offset >= 0 && searchLogic.IsMissingValue(variableName, offset)) {
+      while (offset >= 0 && searchLogic.IsMissingValue(columnIndex, offset)) {
         offset--;
       }
@@ -81,7 +80,7 @@
     }
 
-    private int indexOfNextPresentValue(string variableName, int start) {
+    private int indexOfNextPresentValue(int columnIndex, int start) {
       int offset = start + 1;
-      while (offset < preprocessingData.Rows && searchLogic.IsMissingValue(variableName, offset)) {
+      while (offset < preprocessingData.Rows && searchLogic.IsMissingValue(columnIndex, offset)) {
         offset++;
       }
@@ -90,13 +89,13 @@
     }
 
-    public void ReplaceIndicesByMostCommonValue(string variableName, IEnumerable<int> indices) {
-      if (preprocessingData.IsType<double>(variableName)) {
-        ReplaceIndicesByValue<double>(variableName, indices, statisticInfo.GetMostCommonValue<double>(variableName));
-      } else if (preprocessingData.IsType<string>(variableName)) {
-        ReplaceIndicesByValue<string>(variableName, indices, statisticInfo.GetMostCommonValue<string>(variableName));
-      } else if (preprocessingData.IsType<DateTime>(variableName)) {
-        ReplaceIndicesByValue<DateTime>(variableName, indices, statisticInfo.GetMostCommonValue<DateTime>(variableName));
+    public void ReplaceIndicesByMostCommonValue(int columnIndex, IEnumerable<int> rowIndices) {
+      if (preprocessingData.IsType<double>(columnIndex)) {
+        ReplaceIndicesByValue<double>(columnIndex, rowIndices, statisticInfo.GetMostCommonValue<double>(columnIndex));
+      } else if (preprocessingData.IsType<string>(columnIndex)) {
+        ReplaceIndicesByValue<string>(columnIndex, rowIndices, statisticInfo.GetMostCommonValue<string>(columnIndex));
+      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+        ReplaceIndicesByValue<DateTime>(columnIndex, rowIndices, statisticInfo.GetMostCommonValue<DateTime>(columnIndex));
       } else {
-        throw new ArgumentException("column with index: " + variableName + " contains a non supported type.");
+        throw new ArgumentException("column with index: " + columnIndex + " contains a non supported type.");
       }
     }
@@ -131,18 +130,18 @@
 
     public void reOrderToIndices(IList<System.Tuple<int, int>> indices) {
-      foreach (string variableName in preprocessingData.VariableNames) {
-        if (preprocessingData.IsType<double>(variableName)) {
-          reOrderToIndices<double>(variableName, indices);
-        } else if (preprocessingData.IsType<string>(variableName)) {
-          reOrderToIndices<string>(variableName, indices);
-        } else if (preprocessingData.IsType<DateTime>(variableName)) {
-          reOrderToIndices<DateTime>(variableName, indices);
+      for (int i = 0; i < preprocessingData.Columns; ++i) {
+        if (preprocessingData.IsType<double>(i)) {
+          reOrderToIndices<double>(i, indices);
+        } else if (preprocessingData.IsType<string>(i)) {
+          reOrderToIndices<string>(i, indices);
+        } else if (preprocessingData.IsType<DateTime>(i)) {
+          reOrderToIndices<DateTime>(i, indices);
         }
       }
     }
 
-    private void reOrderToIndices<T>(string variableName, IList<Tuple<int, int>> indices) {
+    private void reOrderToIndices<T>(int columnIndex, IList<Tuple<int, int>> indices) {
 
-      List<T> originalData = new List<T>(preprocessingData.GetValues<T>(variableName));
+      List<T> originalData = new List<T>(preprocessingData.GetValues<T>(columnIndex));
 
       // process all columns equally
@@ -152,5 +151,5 @@
 
         T replaceValue = originalData.ElementAt<T>(replaceIndex);
-        preprocessingData.SetCell<T>(variableName, originalIndex, replaceValue);
+        preprocessingData.SetCell<T>(columnIndex, originalIndex, replaceValue);
       }
     }
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/SearchLogic.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/SearchLogic.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/SearchLogic.cs	(revision 10367)
@@ -15,30 +15,30 @@
       var dic = new Dictionary<string, IEnumerable<int>>();
       foreach (string variableName in preprocessingData.VariableNames) {
-        dic.Add(variableName, GetMissingValueIndices(variableName));
+        dic.Add(variableName, GetMissingValueIndices(preprocessingData.GetColumnIndex(variableName)));
       }
       return dic;
     }
 
-    public bool IsMissingValue(string variableName, int rowIndex) {
-      if (preprocessingData.IsType<double>(variableName)) {
-        return double.IsNaN(preprocessingData.GetCell<double>(variableName, rowIndex));
-      } else if (preprocessingData.IsType<string>(variableName)) {
-        return string.IsNullOrEmpty(preprocessingData.GetCell<string>(variableName, rowIndex));
-      } else if (preprocessingData.IsType<DateTime>(variableName)) {
-        return preprocessingData.GetCell<DateTime>(variableName, rowIndex).Equals(DateTime.MinValue);
+    public bool IsMissingValue(int columnIndex, int rowIndex) {
+      if (preprocessingData.IsType<double>(columnIndex)) {
+        return double.IsNaN(preprocessingData.GetCell<double>(columnIndex, rowIndex));
+      } else if (preprocessingData.IsType<string>(columnIndex)) {
+        return string.IsNullOrEmpty(preprocessingData.GetCell<string>(columnIndex, rowIndex));
+      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+        return preprocessingData.GetCell<DateTime>(columnIndex, rowIndex).Equals(DateTime.MinValue);
       } else {
-        throw new ArgumentException("cell in column with variableName: " + variableName + " and row index " + rowIndex + " contains a non supported type.");
+        throw new ArgumentException("cell in column " + columnIndex + " and row index " + rowIndex + " contains a non supported type.");
       }
     }
 
-    public IEnumerable<int> GetMissingValueIndices(string variableName) {
-      if (preprocessingData.IsType<double>(variableName)) {
-        return preprocessingData.GetValues<double>(variableName).Select((s, i) => new { i, s }).Where(t => double.IsNaN(t.s)).Select(t => t.i);
-      } else if (preprocessingData.IsType<string>(variableName)) {
-        return preprocessingData.GetValues<string>(variableName).Select((s, i) => new { i, s }).Where(t => string.IsNullOrEmpty(t.s)).Select(t => t.i);
-      } else if (preprocessingData.IsType<DateTime>(variableName)) {
-        return preprocessingData.GetValues<DateTime>(variableName).Select((s, i) => new { i, s }).Where(t => t.s.Equals(DateTime.MinValue)).Select(t => t.i);
+    public IEnumerable<int> GetMissingValueIndices(int columnIndex) {
+      if (preprocessingData.IsType<double>(columnIndex)) {
+        return preprocessingData.GetValues<double>(columnIndex).Select((s, i) => new { i, s }).Where(t => double.IsNaN(t.s)).Select(t => t.i);
+      } else if (preprocessingData.IsType<string>(columnIndex)) {
+        return preprocessingData.GetValues<string>(columnIndex).Select((s, i) => new { i, s }).Where(t => string.IsNullOrEmpty(t.s)).Select(t => t.i);
+      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+        return preprocessingData.GetValues<DateTime>(columnIndex).Select((s, i) => new { i, s }).Where(t => t.s.Equals(DateTime.MinValue)).Select(t => t.i);
       } else {
-        throw new ArgumentException("column with variableName: " + variableName + " contains a non supported type.");
+        throw new ArgumentException("column " + columnIndex + " contains a non supported type.");
       }
     }
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsContent.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsContent.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsContent.cs	(revision 10367)
@@ -14,7 +14,9 @@
 
     private readonly IStatisticsLogic statisticsLogic;
-    public StatisticsContent(IStatisticsLogic theStatisticsLogic)
+    private readonly IDataGridLogic dataGridLogic;
+    public StatisticsContent(IStatisticsLogic theStatisticsLogic, IDataGridLogic theDataGridLogic)
     {
       statisticsLogic = theStatisticsLogic;
+      dataGridLogic = theDataGridLogic;
     }
 
@@ -27,8 +29,9 @@
     public IStatisticsLogic StatisticsLogic
     {
-      get
-      {
-        return statisticsLogic;
-      }
+      get { return statisticsLogic; }
+    }
+
+    public IDataGridLogic DataDridLogic {
+      get { return dataGridLogic; }
     }
 
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsLogic.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsLogic.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsLogic.cs	(revision 10367)
@@ -39,40 +39,40 @@
     public int GetMissingValueCount() {
       int count = 0;
-      foreach (var variableName in preprocessingData.VariableNames) {
-        count += GetMissingValueCount(variableName);
+      for(int i = 0; i < preprocessingData.Columns; ++i){
+        count += GetMissingValueCount(i);
       }
       return count;
     }
 
-    public int GetMissingValueCount(string variableName) {
-      return searchLogic.GetMissingValueIndices(variableName).Count();
+    public int GetMissingValueCount(int columnIndex) {
+      return searchLogic.GetMissingValueIndices(columnIndex).Count();
     }
 
-    public T GetMin<T>(string variableName) where T : IComparable<T> {
-      return preprocessingData.GetValues<T>(variableName).Min();
+    public T GetMin<T>(int columnIndex) where T : IComparable<T> {
+      return preprocessingData.GetValues<T>(columnIndex).Min();
     }
 
-    public T GetMax<T>(string variableName) where T : IComparable<T> {
-      return preprocessingData.GetValues<T>(variableName).Max();
+    public T GetMax<T>(int columnIndex) where T : IComparable<T> {
+      return preprocessingData.GetValues<T>(columnIndex).Max();
     }
 
-    public double GetMedian(string variableName) {
+    public double GetMedian(int columnIndex) {
       double median = double.NaN;
-      if (preprocessingData.IsType<double>(variableName)) {
-        median = preprocessingData.GetValues<double>(variableName).Median();
+      if (preprocessingData.IsType<double>(columnIndex)) {
+        median = preprocessingData.GetValues<double>(columnIndex).Median();
       }
       return median;
     }
 
-    public double GetAverage(string variableName) {
+    public double GetAverage(int columnIndex) {
       double avg = double.NaN;
-      if (preprocessingData.IsType<double>(variableName)) {
-        avg = preprocessingData.GetValues<double>(variableName).Average();
+      if (preprocessingData.IsType<double>(columnIndex)) {
+        avg = preprocessingData.GetValues<double>(columnIndex).Average();
       }
       return avg;
     }
 
-    public T GetMostCommonValue<T>(string variableName) {
-      return preprocessingData.GetValues<T>(variableName)
+    public T GetMostCommonValue<T>(int columnIndex) {
+      return preprocessingData.GetValues<T>(columnIndex)
                               .GroupBy(x => x)
                               .OrderByDescending(g => g.Count())
@@ -82,28 +82,28 @@
 
 
-    public double GetStandardDeviation(string variableName) {
+    public double GetStandardDeviation(int columnIndex) {
       double stdDev = double.NaN;
-      if (preprocessingData.IsType<double>(variableName)) {
-        stdDev = preprocessingData.GetValues<double>(variableName).StandardDeviation();
+      if (preprocessingData.IsType<double>(columnIndex)) {
+        stdDev = preprocessingData.GetValues<double>(columnIndex).StandardDeviation();
       }
       return stdDev;
     }
 
-    public double GetVariance(string variableName) {
+    public double GetVariance(int columnIndex) {
       double stdDev = double.NaN;
-      if (preprocessingData.IsType<double>(variableName)) {
-        stdDev = preprocessingData.GetValues<double>(variableName).Variance();
+      if (preprocessingData.IsType<double>(columnIndex)) {
+        stdDev = preprocessingData.GetValues<double>(columnIndex).Variance();
       }
       return stdDev;
     }
 
-    public int GetDifferentValuesCount<T>(string variableName) {
-      return preprocessingData.GetValues<T>(variableName).GroupBy(x => x).Count();
+    public int GetDifferentValuesCount<T>(int columnIndex) {
+      return preprocessingData.GetValues<T>(columnIndex).GroupBy(x => x).Count();
     }
 
     public int GetRowMissingValueCount(int rowIndex) {
       int count = 0;
-      foreach (var variableName in preprocessingData.VariableNames) {
-        if (searchLogic.IsMissingValue(variableName, rowIndex)) {
+       for(int i = 0; i < preprocessingData.Columns; ++i){
+        if (searchLogic.IsMissingValue(i, rowIndex)) {
           ++count;
         }
@@ -111,4 +111,13 @@
       return count;
     }
+
+
+    public string GetVariableName(int columnIndex) {
+      return preprocessingData.GetVariableName(columnIndex);
+    }
+
+    public bool IsType<T>(int columnIndex) {
+      return preprocessingData.IsType<T>(columnIndex);
+    }
   }
 }
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IDataGridLogic.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IDataGridLogic.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IDataGridLogic.cs	(revision 10367)
@@ -3,4 +3,5 @@
   public interface IDataGridLogic {
     IEnumerable<string> ColumnNames { get; }
+    string GetColumnTypeAsString(int columnIndex);
     IEnumerable<string> RowNames { get; }
     int Columns { get; }
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingData.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingData.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingData.cs	(revision 10367)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using HeuristicLab.Core;
@@ -28,10 +29,23 @@
 
   public interface IPreprocessingData : INamedItem {
-    T GetCell<T>(string variableName, int row);
-    void SetCell<T>(string variableName, int row, T value);
-    string GetCellAsString(string variableName, int row);
+    [Obsolete("use the index based variant, is faster")]
+    T GetCell<T>(string variableName, int rowIndex);
+    T GetCell<T>(int columnIndex, int rowIndex);
 
+    [Obsolete("use the index based variant, is faster")]
+    void SetCell<T>(string variableName, int rowIndex, T value);
+    void SetCell<T>(int columnIndex, int rowIndex, T value);
+
+    [Obsolete("use the index based variant, is faster")]
+    string GetCellAsString(string variableName, int rowIndex);
+    string GetCellAsString(int columnIndex, int rowIndex);
+
+    [Obsolete("use the index based variant, is faster")]
     IList<T> GetValues<T>(string variableName);
+    IList<T> GetValues<T>(int columnIndex);
+
+    [Obsolete("use the index based variant, is faster")]
     void SetValues<T>(string variableName, IList<T> values);
+    void SetValues<T>(int columnIndex, IList<T> values);
 
     void InsertRow(int rowIndex);
@@ -39,5 +53,8 @@
 
     void InsertColumn<T>(string variableName, int columnIndex);
+
+    [Obsolete("use the index based variant, is faster")]
     void DeleteColumn(string variableName);
+    void DeleteColumn(int columnIndex);
 
     IntRange TrainingPartition { get; }
@@ -46,5 +63,10 @@
     IEnumerable<string> VariableNames { get; }
     string GetVariableName(int columnIndex);
+    int GetColumnIndex(string variableName);
+
+    [Obsolete("use the index based variant, is faster")]
     bool IsType<T>(string variableName);
+    bool IsType<T>(int columnIndex);
+
 
     int Columns { get; }
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingDataManipulation.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingDataManipulation.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingDataManipulation.cs	(revision 10367)
@@ -5,10 +5,10 @@
     void reOrderToIndices(IEnumerable<int> indices);
     void reOrderToIndices(IList<Tuple<int, int>> indices);
-    void ReplaceIndicesByAverageValue(string variableName, IEnumerable<int> indices);
-    void ReplaceIndicesByLinearInterpolationOfNeighbours(string variableName, IEnumerable<int> indices);
-    void ReplaceIndicesByMedianValue(string variableName, IEnumerable<int> indices);
-    void ReplaceIndicesByMostCommonValue(string variableName, IEnumerable<int> indices);
-    void ReplaceIndicesByRandomValue(string variableName, IEnumerable<int> indices);
-    void ReplaceIndicesByValue<T>(string variableName, IEnumerable<int> indices, T value);
+    void ReplaceIndicesByAverageValue(int columnIndex, IEnumerable<int> rowIndices);
+    void ReplaceIndicesByLinearInterpolationOfNeighbours(int columnIndex, IEnumerable<int> rowIndices);
+    void ReplaceIndicesByMedianValue(int columnIndex, IEnumerable<int> rowIndices);
+    void ReplaceIndicesByMostCommonValue(int columnIndex, IEnumerable<int> rowIndices);
+    void ReplaceIndicesByRandomValue(int columnIndex, IEnumerable<int> rowIndices);
+    void ReplaceIndicesByValue<T>(int columnIndex, IEnumerable<int> rowIndices, T value);
     void ShuffleWithRanges(IEnumerable<HeuristicLab.Data.IntRange> ranges);
   }
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/ISearchLogic.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/ISearchLogic.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/ISearchLogic.cs	(revision 10367)
@@ -17,7 +17,7 @@
     /// </summary>
     /// <returns></returns>
-    IEnumerable<int> GetMissingValueIndices(string variableName);
+    IEnumerable<int> GetMissingValueIndices(int columnIndex);
 
-    bool IsMissingValue(string variableName, int rowIndex);
+    bool IsMissingValue(int columnIndex, int rowIndex);
   }
 }
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticsLogic.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticsLogic.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticsLogic.cs	(revision 10367)
@@ -9,14 +9,15 @@
     int GetNominalColumnCount();
     int GetMissingValueCount();
-    int GetMissingValueCount(string variableName);
+    int GetMissingValueCount(int columnIndex);
     int GetRowMissingValueCount(int rowIndex);
-    T GetMin<T>(string variableName) where T : IComparable<T>;
-    T GetMax<T>(string variableName) where T : IComparable<T>;
-    double GetMedian(string variableName);
-    double GetAverage(string variableName);
-    T GetMostCommonValue<T>(string variableName);
-    double GetStandardDeviation(string variableName);
-    double GetVariance(string variableName);
-    int GetDifferentValuesCount<T>(string variableName);
+    T GetMin<T>(int columnIndex) where T : IComparable<T>;
+    T GetMax<T>(int columnIndex) where T : IComparable<T>;
+    double GetMedian(int columnIndex);
+    double GetAverage(int columnIndex);
+    T GetMostCommonValue<T>(int columnIndex);
+    double GetStandardDeviation(int columnIndex);
+    double GetVariance(int columnIndex);
+    int GetDifferentValuesCount<T>(int columnIndex);
+    bool IsType<T>(int columnIndex);
   }
 }
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Views/DataPreprocessingView.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Views/DataPreprocessingView.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Views/DataPreprocessingView.cs	(revision 10367)
@@ -45,6 +45,7 @@
       IPreprocessingData data = Content.Data;
       ISearchLogic searchLogic = new SearchLogic(data);
-      dataGridContent = new DataGridContent(new DataGridLogic(data), new PreprocessingDataManipulation(data, searchLogic, new StatisticsLogic(data, searchLogic)));
-      statisticsContent = new StatisticsContent(new StatisticsLogic(data, searchLogic));
+      var dataGridLogic = new DataGridLogic(data);
+      dataGridContent = new DataGridContent(dataGridLogic, new PreprocessingDataManipulation(data, searchLogic, new StatisticsLogic(data, searchLogic)));
+      statisticsContent = new StatisticsContent(new StatisticsLogic(data, searchLogic), dataGridLogic);
       filterContent = new FilterContent(new FilterLogic());
       tranformationContent = new TransformationContent(new TransformationLogic());
Index: /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Views/StatisticsView.Designer.cs
===================================================================
--- /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Views/StatisticsView.Designer.cs	(revision 10366)
+++ /branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Views/StatisticsView.Designer.cs	(revision 10367)
@@ -34,6 +34,6 @@
       this.lblNominalColumns = new System.Windows.Forms.Label();
       this.txtMissingValuesTotal = new System.Windows.Forms.Label();
-      this.dataGridView1 = new System.Windows.Forms.DataGridView();
-      ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).BeginInit();
+      this.dataGridView = new System.Windows.Forms.DataGridView();
+      ((System.ComponentModel.ISupportInitialize)(this.dataGridView)).BeginInit();
       this.SuspendLayout();
       // 
@@ -128,11 +128,12 @@
       this.txtMissingValuesTotal.Text = "102";
       // 
-      // dataGridView1
+      // dataGridView
       // 
-      this.dataGridView1.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
-      this.dataGridView1.Location = new System.Drawing.Point(5, 117);
-      this.dataGridView1.Name = "dataGridView1";
-      this.dataGridView1.Size = new System.Drawing.Size(531, 278);
-      this.dataGridView1.TabIndex = 4;
+      this.dataGridView.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
+      this.dataGridView.Location = new System.Drawing.Point(5, 117);
+      this.dataGridView.Name = "dataGridView";
+      this.dataGridView.Size = new System.Drawing.Size(531, 278);
+      this.dataGridView.TabIndex = 4;
+      this.dataGridView.CellValueNeeded += new System.Windows.Forms.DataGridViewCellValueEventHandler(this.dataGridView_CellValueNeeded);
       // 
       // StatisticsView
@@ -140,5 +141,5 @@
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
       this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-      this.Controls.Add(this.dataGridView1);
+      this.Controls.Add(this.dataGridView);
       this.Controls.Add(this.lblNominalColumns);
       this.Controls.Add(this.lblNumericColumns);
@@ -153,5 +154,5 @@
       this.Name = "StatisticsView";
       this.Size = new System.Drawing.Size(549, 408);
-      ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).EndInit();
+      ((System.ComponentModel.ISupportInitialize)(this.dataGridView)).EndInit();
       this.ResumeLayout(false);
       this.PerformLayout();
@@ -171,5 +172,5 @@
     private System.Windows.Forms.Label lblNominalColumns;
     private System.Windows.Forms.Label txtMissingValuesTotal;
-    private System.Windows.Forms.DataGridView dataGridView1;
+    private System.Windows.Forms.DataGridView dataGridView;
   }
 }
