Changeset 10367 for branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations

Timestamp:

01/22/14 14:13:11 (11 years ago)

Author:

rstoll

Message:

• modified PreprocessingData, uses columnIndex now instead of variableName (is faster and more convenient), set variabelName based methods to Obsolete
• Already changed SearchLogic, DataGridLogic, StatisticLogic as well as PreprocessingDataManipulation

*

Location:

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations

Files:

• DataGridLogic.cs (modified) (6 diffs)
• PreprocessingData.cs (modified) (8 diffs)
• PreprocessingDataManipulation.cs (modified) (9 diffs)
• SearchLogic.cs (modified) (1 diff)
• StatisticsContent.cs (modified) (2 diffs)
• StatisticsLogic.cs (modified) (3 diffs)

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/DataGridLogic.cs

@@ -32 +32 @@
     }
 
+    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 +54 @@
       }
       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 +61 @@
           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 +67 @@
           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 +75 @@
         }
       } else {
-        throw new ArgumentException("column with variableName: " + variableName + " contains a non supported type.");
+        throw new ArgumentException("column " + columnIndex + " contains a non supported type.");
       }
 
@@ -72 +82 @@
 
     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.");
       }
 

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingData.cs

@@ -33 +33 @@
   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 +41 @@
     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 +50 @@
       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 +72 @@
       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 +87 @@
     #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 +152 @@
 
     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 +178 @@
     }
 
+    [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 +200 @@
 
     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]);
       }
 

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingDataManipulation.cs

@@ -3 +3 @@
 using System.Linq;
 using HeuristicLab.Data;
-using System.Collections;
 
 namespace HeuristicLab.DataPreprocessing {
@@ -17 +16 @@
     }
 
-    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 +56 @@
             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 +65 @@
           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 +71 @@
     }
 
-    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 +80 @@
     }
 
-    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 +89 @@
     }
 
-    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 +130 @@
 
     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 +151 @@
 
         T replaceValue = originalData.ElementAt<T>(replaceIndex);
-        preprocessingData.SetCell<T>(variableName, originalIndex, replaceValue);
+        preprocessingData.SetCell<T>(columnIndex, originalIndex, replaceValue);
       }
     }

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/SearchLogic.cs

@@ -15 +15 @@
       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.");
       }
     }

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsContent.cs

@@ -14 +14 @@
 
     private readonly IStatisticsLogic statisticsLogic;
-    public StatisticsContent(IStatisticsLogic theStatisticsLogic)
+    private readonly IDataGridLogic dataGridLogic;
+    public StatisticsContent(IStatisticsLogic theStatisticsLogic, IDataGridLogic theDataGridLogic)
     {
       statisticsLogic = theStatisticsLogic;
+      dataGridLogic = theDataGridLogic;
     }
 
@@ -27 +29 @@
     public IStatisticsLogic StatisticsLogic
     {
-      get
-      {
-        return statisticsLogic;
-      }
+      get { return statisticsLogic; }
+    }
+
+    public IDataGridLogic DataDridLogic {
+      get { return dataGridLogic; }
     }
 

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsLogic.cs

@@ -39 +39 @@
     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 +82 @@
 
 
-    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 +111 @@
       return count;
     }
+
+
+    public string GetVariableName(int columnIndex) {
+      return preprocessingData.GetVariableName(columnIndex);
+    }
+
+    public bool IsType<T>(int columnIndex) {
+      return preprocessingData.IsType<T>(columnIndex);
+    }
   }
 }