Changeset 10165 for branches/DataPreprocessing/HeuristicLab.DataPreprocessing

Timestamp:

11/27/13 16:34:23 (11 years ago)

Author:

rstoll

Message:

Implementation changed for new IPreprocessingData

Location:

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3

Files:

• Interfaces/IPreprocessingData.cs (modified) (1 diff)
• PreprocessingDataStatisticInfo.cs (modified) (2 diffs)

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingData.cs

@@ -27 +27 @@
 
   public interface IPreprocessingData : INamedItem {
-    T GetCell<T>(int columnIndex, int rowIndex);
-    void SetCell<T>(int columnIndex, int rowIndex, T value);
+    T GetCell<T>(int rowIndex, int columnIndex);
+    void SetCell<T>(int rowIndex, int columnIndex, T value);
 
     IList<T> GetValues<T>(int columnIndex);

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/PreprocessingDataStatisticInfo.cs

@@ -1 +1 @@
 using System;
+using System.Linq;
 using HeuristicLab.DataPreprocessing.Interfaces;
 
 namespace HeuristicLab.DataPreprocessing {
+
   class PreprocessingDataStatisticInfo : IPreprocessingDataStatisticInfo {
 
     private IPreprocessingData preprocessingData;
 
-    public PreprocessingDataStatisticInfo(IPreprocessingData theDataSet) {
-      preprocessingData = theDataSet;
+    public PreprocessingDataStatisticInfo(IPreprocessingData thePreprocessingData) {
+      preprocessingData = thePreprocessingData;
     }
-
 
     public int GetColumnCount() {
@@ -43 +44 @@
 
     public int GetMissingValueCount(int columnIndex) {
-      throw new System.NotImplementedException();
-      //Func<dynamic, bool> isMissingValueFunc;
-      //if (preprocessingData.IsType<double>(columnIndex)) {
-      //  isMissingValueFunc = IsMissingDoubleValue;
-      //} else if (preprocessingData.IsType<string>(columnIndex)) {
-      //  isMissingValueFunc = IsMissingStringValue;
-      //} else if (preprocessingData.IsType<DateTime>(columnIndex)) {
-      //  isMissingValueFunc = isMissingDateTimeValue;
-      //} else {
-      //  throw new ArgumentException("column with index: " + columnIndex + " contains a non supported type.");
-      //}
-
-      //int count = 0;
-      //for (int i = 0; i < preprocessingData.Rows; ++i) {
-      //  if (isMissingValueFunc(preprocessingData.GetCell(i, columnIndex))) {
-      //    ++count;
-      //  }
-      //}
-      //return count;
-    }
-
-    private bool IsMissingDoubleValue(string value) {
-      double dummy;
-      bool couldNotParse = !double.TryParse(value, out dummy);
-      return couldNotParse || double.IsNaN(dummy);
-    }
-
-    private bool IsMissingStringValue(string value) {
-      return string.IsNullOrEmpty(value);
-    }
-
-    private bool isMissingDateTimeValue(string value) {
-      DateTime dateTime;
-      bool couldNotParse = DateTime.TryParse(value, out dateTime);
-      return couldNotParse || dateTime.Equals(DateTime.MinValue);
+      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));
+      } else {
+        throw new ArgumentException("column with index: " + columnIndex + " contains a non supported type.");
+      }
     }
 
     public T GetMin<T>(int columnIndex) where T : IComparable<T> {
-      if (!preprocessingData.IsType<double>(columnIndex)) {
-        throw new ArgumentException("column with index: " + columnIndex + " was assumed to be of type " + typeof(T).Name + " but was different.");
-      }
-      if (typeof(T) == typeof(double)) {
-        return (dynamic)GetMin(columnIndex, double.MaxValue, IsMissingDoubleValue, double.Parse); ;
-      } else if (typeof(T) == typeof(DateTime)) {
-        return (dynamic)GetMin(columnIndex, DateTime.MaxValue, IsMissingDoubleValue, DateTime.Parse);
-      } else {
-        throw new ArgumentException("type of T is not supported");
-      }
+      return preprocessingData.GetValues<T>(columnIndex).Min();
     }
 
     public T GetMax<T>(int columnIndex) where T : IComparable<T> {
-      if (!preprocessingData.IsType<double>(columnIndex)) {
-        throw new ArgumentException("column with index: " + columnIndex + " was assumed to be of type " + typeof(T).Name + " but was different.");
-      }
-      if (typeof(T) == typeof(double)) {
-        return (dynamic)GetMax(columnIndex, double.MinValue, IsMissingDoubleValue, double.Parse); ;
-      } else if (typeof(T) == typeof(DateTime)) {
-        return (dynamic)GetMax(columnIndex, DateTime.MinValue, IsMissingDoubleValue, DateTime.Parse);
-      } else {
-        throw new ArgumentException("type of T is not supported");
-      }
+      return preprocessingData.GetValues<T>(columnIndex).Max();
     }
-
-    private T GetMin<T>(int columnIndex, T max, Func<string, bool> isMissingValueFunc, Func<string, T> parseFunc) where T : IComparable<T> {
-      throw new System.NotImplementedException();
-      //T min = max;
-      //for (int i = 0; i < preprocessingData.Rows; ++i) {
-      //  var value = preprocessingData.GetValue(i, columnIndex);
-      //  if (!isMissingValueFunc(value)) {
-      //    T parsedValue = parseFunc(value);
-      //    if (parsedValue.CompareTo(min) < 0) {
-      //      min = parsedValue;
-      //    }
-      //  }
-      //}
-      //return min;
-    }
-
-    private T GetMax<T>(int columnIndex, T min, Func<string, bool> isMissingValueFunc, Func<string, T> parseFunc) where T : IComparable<T> {
-      throw new System.NotImplementedException();
-      //T max = min;
-      //for (int i = 0; i < preprocessingData.Rows; ++i) {
-      //  var value = preprocessingData.GetValue(i, columnIndex);
-      //  if (!isMissingValueFunc(value)) {
-      //    T parsedValue = parseFunc(value);
-      //    if (parsedValue.CompareTo(min) > 0) {
-      //      max = parsedValue;
-      //    }
-      //  }
-      //}
-      //return max;
-    }
-
-
-
-
 
     public double GetMedian(int columnIndex) {