source: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticInfo.cs @ 10182

using System;
using System.Linq;
using HeuristicLab.DataPreprocessing;

namespace HeuristicLab.DataPreprocessing {

  class StatisticInfo : IStatisticInfo {

    private IPreprocessingData preprocessingData;

    public StatisticInfo(IPreprocessingData thePreprocessingData) {
      preprocessingData = thePreprocessingData;
    }

    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) {
      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> {
      return preprocessingData.GetValues<T>(columnIndex).Min();
    }

    public T GetMax<T>(int columnIndex) where T : IComparable<T> {
      return preprocessingData.GetValues<T>(columnIndex).Max();
    }

    public double GetMedian(int columnIndex) {
      double median = double.NaN;
      if (preprocessingData.IsType<double>(columnIndex)) {
        median = preprocessingData.GetValues<double>(columnIndex).OrderBy(x => x).ElementAt(preprocessingData.Rows / 2);
      }
      return median;
    }

    public double GetAverage(int columnIndex) {
      double avg = double.NaN;
      if (preprocessingData.IsType<double>(columnIndex)) {
        avg = preprocessingData.GetValues<double>(columnIndex).Average();
      }
      return avg;
    }

    public T GetMostCommonValue<T>(int columnIndex) {
      return preprocessingData.GetValues<T>(columnIndex)
                              .GroupBy(x => x)
                              .OrderByDescending(g => g.Count())
                              .Select(g => g.Key)
                              .First();
    }


    public double GetStandardDeviation(int columnIndex) {
      double stdDev = double.NaN;
      if (preprocessingData.IsType<double>(columnIndex)) {
        double avg = GetAverage(columnIndex);
        stdDev = Math.Sqrt(preprocessingData.GetValues<double>(columnIndex).Sum(x => (x - avg) * (x - avg)) / (preprocessingData.Rows - 1));
      }
      return stdDev;
    }

    public int GetDifferentValuesCount<T>(int columnIndex) {
      return preprocessingData.GetValues<T>(columnIndex).GroupBy(x => x).Count();
    }
  }
}