Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticInfo.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticInfo.cs	(revision 10182)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticInfo.cs	(revision 10183)
@@ -1,9 +1,8 @@
 ﻿using System;
 using System.Linq;
-using HeuristicLab.DataPreprocessing;
 
 namespace HeuristicLab.DataPreprocessing {
 
-  class StatisticInfo : IStatisticInfo {
+  public class StatisticInfo : IStatisticInfo {
 
     private IPreprocessingData preprocessingData;
@@ -23,6 +22,6 @@
     public int GetNumericColumnCount() {
       int count = 0;
-      for (int i = 0; i < preprocessingData.Columns; ++i) {
-        if (preprocessingData.IsType<double>(i)) {
+      foreach (var variableName in preprocessingData.VariableNames) {
+        if (preprocessingData.IsType<double>(variableName)) {
           ++count;
         }
@@ -37,48 +36,48 @@
     public int GetMissingValueCount() {
       int count = 0;
-      for (int i = 0; i < preprocessingData.Columns; ++i) {
-        count += GetMissingValueCount(i);
+      foreach (var variableName in preprocessingData.VariableNames) {
+        count += GetMissingValueCount(variableName);
       }
       return count;
     }
 
-    public int GetMissingValueCount(int columnIndex) {
-      if (preprocessingData.IsType<double>(columnIndex)) {
-        return preprocessingData.GetValues<double>(columnIndex).Count(x => double.IsNaN(x));
-      } else if (preprocessingData.IsType<string>(columnIndex)) {
-        return preprocessingData.GetValues<string>(columnIndex).Count(x => string.IsNullOrEmpty(x));
-      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
-        return preprocessingData.GetValues<DateTime>(columnIndex).Count(x => x.Equals(DateTime.MinValue));
+    public int GetMissingValueCount(string variableName) {
+      if (preprocessingData.IsType<double>(variableName)) {
+        return preprocessingData.GetValues<double>(variableName).Count(x => double.IsNaN(x));
+      } else if (preprocessingData.IsType<string>(variableName)) {
+        return preprocessingData.GetValues<string>(variableName).Count(x => string.IsNullOrEmpty(x));
+      } else if (preprocessingData.IsType<DateTime>(variableName)) {
+        return preprocessingData.GetValues<DateTime>(variableName).Count(x => x.Equals(DateTime.MinValue));
       } else {
-        throw new ArgumentException("column with index: " + columnIndex + " contains a non supported type.");
+        throw new ArgumentException("column with index: " + variableName + " contains a non supported type.");
       }
     }
 
-    public T GetMin<T>(int columnIndex) where T : IComparable<T> {
-      return preprocessingData.GetValues<T>(columnIndex).Min();
+    public T GetMin<T>(string variableName) where T : IComparable<T> {
+      return preprocessingData.GetValues<T>(variableName).Min();
     }
 
-    public T GetMax<T>(int columnIndex) where T : IComparable<T> {
-      return preprocessingData.GetValues<T>(columnIndex).Max();
+    public T GetMax<T>(string variableName) where T : IComparable<T> {
+      return preprocessingData.GetValues<T>(variableName).Max();
     }
 
-    public double GetMedian(int columnIndex) {
+    public double GetMedian(string variableName) {
       double median = double.NaN;
-      if (preprocessingData.IsType<double>(columnIndex)) {
-        median = preprocessingData.GetValues<double>(columnIndex).OrderBy(x => x).ElementAt(preprocessingData.Rows / 2);
+      if (preprocessingData.IsType<double>(variableName)) {
+        median = preprocessingData.GetValues<double>(variableName).OrderBy(x => x).ElementAt(preprocessingData.Rows / 2);
       }
       return median;
     }
 
-    public double GetAverage(int columnIndex) {
+    public double GetAverage(string variableName) {
       double avg = double.NaN;
-      if (preprocessingData.IsType<double>(columnIndex)) {
-        avg = preprocessingData.GetValues<double>(columnIndex).Average();
+      if (preprocessingData.IsType<double>(variableName)) {
+        avg = preprocessingData.GetValues<double>(variableName).Average();
       }
       return avg;
     }
 
-    public T GetMostCommonValue<T>(int columnIndex) {
-      return preprocessingData.GetValues<T>(columnIndex)
+    public T GetMostCommonValue<T>(string variableName) {
+      return preprocessingData.GetValues<T>(variableName)
                               .GroupBy(x => x)
                               .OrderByDescending(g => g.Count())
@@ -88,15 +87,15 @@
 
 
-    public double GetStandardDeviation(int columnIndex) {
+    public double GetStandardDeviation(string variableName) {
       double stdDev = double.NaN;
-      if (preprocessingData.IsType<double>(columnIndex)) {
-        double avg = GetAverage(columnIndex);
-        stdDev = Math.Sqrt(preprocessingData.GetValues<double>(columnIndex).Sum(x => (x - avg) * (x - avg)) / (preprocessingData.Rows - 1));
+      if (preprocessingData.IsType<double>(variableName)) {
+        double avg = GetAverage(variableName);
+        stdDev = Math.Sqrt(preprocessingData.GetValues<double>(variableName).Sum(x => (x - avg) * (x - avg)) / (preprocessingData.Rows - 1));
       }
       return stdDev;
     }
 
-    public int GetDifferentValuesCount<T>(int columnIndex) {
-      return preprocessingData.GetValues<T>(columnIndex).GroupBy(x => x).Count();
+    public int GetDifferentValuesCount<T>(string variableName) {
+      return preprocessingData.GetValues<T>(variableName).GroupBy(x => x).Count();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticInfo.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticInfo.cs	(revision 10182)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticInfo.cs	(revision 10183)
@@ -9,12 +9,12 @@
     int GetNominalColumnCount();
     int GetMissingValueCount();
-    int GetMissingValueCount(int columnIndex);
-    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);
-    int GetDifferentValuesCount<T>(int columnIndex);
+    int GetMissingValueCount(string variableName);
+    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);
+    int GetDifferentValuesCount<T>(string variableName);
   }
 }
