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

Timestamp:

01/22/14 14:13:11 (10 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

*

File:

• branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingData.cs (modified) (8 diffs)

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]);
       }