source: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/DataSetStatisticInfo.cs @ 10148

using System;
using System.Linq;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.DataPreprocessing {
  class DatasetStatisticInfo : IDatasetStatisticInfo {

    private IDataset dataSet;

    public DatasetStatisticInfo(IDataset theDataSet) {
      dataSet = theDataSet;
    }


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

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

    public int GetNumericColumnCount() {
      return dataSet.DoubleVariables.Count();
    }

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

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

    public int GetMissingValueCount(int columnIndex) {
      Func<string, bool> isMissingValueFunc;
      if (dataSet.IsType<double>(columnIndex)) {
        isMissingValueFunc = IsMissingDoubleValue;
      } else if (dataSet.IsType<string>(columnIndex)) {
        isMissingValueFunc = IsMissingStringValue;
      } else if (dataSet.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 < dataSet.Rows; ++i) {
        if (isMissingValueFunc(dataSet.GetValue(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 (!dataSet.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 (!dataSet.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> {
      T min = max;
      for (int i = 0; i < dataSet.Rows; ++i) {
        var value = dataSet.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> {
      T max = min;
      for (int i = 0; i < dataSet.Rows; ++i) {
        var value = dataSet.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) {
      throw new System.NotImplementedException();
    }

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

  }
}