source: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/PreprocessingDataStatisticInfo.cs @ 10161

using System;
using HeuristicLab.DataPreprocessing.Interfaces;

namespace HeuristicLab.DataPreprocessing {
  class DatasetStatisticInfo : IDatasetStatisticInfo {

    private IPreprocessingData preprocessingData;

    public DatasetStatisticInfo(IPreprocessingData theDataSet) {
      preprocessingData = theDataSet;
    }


    public int GetColumnCount() {
      return preprocessingData.Columns;
    }

    public int GetRowCount() {
      return preprocessingData.Rows;
    }

    public int GetNumericColumnCount() {
      int count = 0;
      for (int i = 0; i < preprocessingData.Columns; ++i) {
        if (preprocessingData.IsType<double>(i)) {
          ++count;
        }
      }
      return count;
    }

    public int GetNominalColumnCount() {
      return preprocessingData.Columns - GetNumericColumnCount();
    }

    public int GetMissingValueCount() {
      int count = 0;
      for (int i = 0; i < preprocessingData.Columns; ++i) {
        count += GetMissingValueCount(i);
      }
      return count;
    }

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

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

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

    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) {
      throw new System.NotImplementedException();
    }

    public double GetAverage(int columnIndex) {
      throw new System.NotImplementedException();
    }

    public double GetMostCommonValue(int columnIndex) {
      double result = 0;
      for (int i = 0; i < preprocessingData.Rows; ++i) {

      }
      return result;
    }

    public double GetStandardDeviation(int columnIndex) {
      throw new System.NotImplementedException();
    }

  }
}