source: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsLogic.cs @ 10355

using System;
using System.Linq;
using HeuristicLab.Common;

namespace HeuristicLab.DataPreprocessing {

  public class StatisticsLogic : IStatisticsLogic {

    private readonly IPreprocessingData preprocessingData;
    private readonly ISearchLogic searchLogic;

    public StatisticsLogic(IPreprocessingData thePreprocessingData, ISearchLogic theSearchLogic) {
      preprocessingData = thePreprocessingData;
      searchLogic = theSearchLogic;
    }

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

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

    public int GetNumericColumnCount() {
      int count = 0;
      foreach (var variableName in preprocessingData.VariableNames) {
        if (preprocessingData.IsType<double>(variableName)) {
          ++count;
        }
      }
      return count;
    }

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

    public int GetMissingValueCount() {
      int count = 0;
      foreach (var variableName in preprocessingData.VariableNames) {
        count += GetMissingValueCount(variableName);
      }
      return count;
    }

    public int GetMissingValueCount(string variableName) {
      return searchLogic.GetMissingValueIndices(variableName).Count();
    }

    public T GetMin<T>(string variableName) where T : IComparable<T> {
      return preprocessingData.GetValues<T>(variableName).Min();
    }

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

    public double GetMedian(string variableName) {
      double median = double.NaN;
      if (preprocessingData.IsType<double>(variableName)) {
        median = preprocessingData.GetValues<double>(variableName).Median();
      }
      return median;
    }

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

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


    public double GetStandardDeviation(string variableName) {
      double stdDev = double.NaN;
      if (preprocessingData.IsType<double>(variableName)) {
        stdDev = preprocessingData.GetValues<double>(variableName).StandardDeviation();
      }
      return stdDev;
    }

    public double GetVariance(string variableName) {
      double stdDev = double.NaN;
      if (preprocessingData.IsType<double>(variableName)) {
        stdDev = preprocessingData.GetValues<double>(variableName).Variance();
      }
      return stdDev;
    }

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

    public int GetRowMissingValueCount(int rowIndex) {
      int count = 0;
      foreach (var variableName in preprocessingData.VariableNames) {
        if (searchLogic.IsMissingValue(variableName, rowIndex)) {
          ++count;
        }
      }
      return count;
    }
  }
}