Changeset 12545


Ignore:
Timestamp:
06/30/15 12:30:04 (4 years ago)
Author:
ehopf
Message:

#2335: Added the recalculation of the Statistics-View if a Filter gets applied (Defect 8) and minor fixes to the statistic calculations.

Location:
branches/DataPreprocessingImprovements
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • branches/DataPreprocessingImprovements/HeuristicLab.DataPreprocessing.Views/3.4/DataPreprocessingView.cs

    r12012 r12545  
    4646      if (Content != null) {
    4747        var data = Content.Data;
    48         var searchLogic = new SearchLogic(data);
     48        var filterLogic = new FilterLogic(data);
     49        var searchLogic = new SearchLogic(data, filterLogic);
    4950        var statisticsLogic = new StatisticsLogic(data, searchLogic);
    5051        var manipulationLogic = new ManipulationLogic(data, searchLogic, statisticsLogic);
    51         var filterLogic = new FilterLogic(data);
    5252
    5353        var viewShortcuts = new ItemList<IViewShortcut> {
  • branches/DataPreprocessingImprovements/HeuristicLab.DataPreprocessing.Views/3.4/StatisticsView.cs

    r12012 r12545  
    166166        "", //standard deviation
    167167        "", //variance
    168         logic.GetMostCommonValue<string>(columnIndex).ToString(),
     168        logic.GetMostCommonValue<string>(columnIndex) ?? "",
    169169        logic.GetDifferentValuesCount<string>(columnIndex).ToString()
    170170      };
  • branches/DataPreprocessingImprovements/HeuristicLab.DataPreprocessing/3.4/Implementations/SearchLogic.cs

    r12012 r12545  
    2323using System.Collections;
    2424using System.Collections.Generic;
    25 using System.Linq;
    2625
    2726namespace HeuristicLab.DataPreprocessing {
    2827  public class SearchLogic : ISearchLogic {
    2928    private readonly ITransactionalPreprocessingData preprocessingData;
     29    private readonly IFilterLogic filterLogic;
    3030
    3131    private Dictionary<int, IList<int>> MissingValueIndicies { get; set; }
     
    4444    }
    4545
    46     public SearchLogic(ITransactionalPreprocessingData thePreprocessingData) {
     46    public SearchLogic(ITransactionalPreprocessingData thePreprocessingData, IFilterLogic theFilterLogic) {
    4747      preprocessingData = thePreprocessingData;
     48      filterLogic = theFilterLogic;
    4849
    4950      MissingValueIndicies = new Dictionary<int, IList<int>>();
    5051      ValuesWithoutNaN = new Dictionary<int, IList>();
    5152
    52       preprocessingData.Changed += preprocessingData_Changed;
     53      preprocessingData.Changed += PreprocessingData_Changed;
     54      filterLogic.FilterChanged += FilterLogic_FilterChanged;
    5355    }
    5456
    55     void preprocessingData_Changed(object sender, DataPreprocessingChangedEventArgs e)
    56     {
     57    void FilterLogic_FilterChanged(object sender, EventArgs e) {
     58      //recalculate
     59      for (int i = 0; i < Columns; i++) {
     60        MissingValueIndicies.Remove(i);
     61        ValuesWithoutNaN.Remove(i);
     62      }
     63    }
     64
     65    void PreprocessingData_Changed(object sender, DataPreprocessingChangedEventArgs e) {
    5766      switch (e.Type) {
    5867        case DataPreprocessingChangedEventType.DeleteColumn:
     
    7382          ValuesWithoutNaN = new Dictionary<int, IList>();
    7483          break;
    75       } 
     84      }
    7685    }
    7786
     
    97106
    98107    public IList<int> GetMissingValueIndices(int columnIndex) {
    99       if (!MissingValueIndicies.ContainsKey(columnIndex)){       
    100           if (preprocessingData.VariableHasType<double>(columnIndex)) {
    101             MissingValueIndicies[columnIndex] = GetMissingValueIndices<double>(columnIndex);
    102           } else if (preprocessingData.VariableHasType<string>(columnIndex)) {
    103             MissingValueIndicies[columnIndex] = GetMissingValueIndices<string>(columnIndex);
    104           } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
    105             MissingValueIndicies[columnIndex] = GetMissingValueIndices<DateTime>(columnIndex);
    106           } else {
    107             throw new ArgumentException("column " + columnIndex + " contains a non supported type.");
    108           }
    109       }
     108      if (!MissingValueIndicies.ContainsKey(columnIndex)) {
     109        if (preprocessingData.VariableHasType<double>(columnIndex)) {
     110          MissingValueIndicies[columnIndex] = GetMissingValueIndices<double>(columnIndex);
     111        } else if (preprocessingData.VariableHasType<string>(columnIndex)) {
     112          MissingValueIndicies[columnIndex] = GetMissingValueIndices<string>(columnIndex);
     113        } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
     114          MissingValueIndicies[columnIndex] = GetMissingValueIndices<DateTime>(columnIndex);
     115        } else {
     116          throw new ArgumentException("column " + columnIndex + " contains a non supported type.");
     117        }
     118      }
     119      return MissingValueIndicies[columnIndex];
     120    }
    110121
    111       return MissingValueIndicies[columnIndex];
    112    }
    113122    private IList<int> GetMissingValueIndices<T>(int columnIndex) {
    114123      List<int> missingIndices = new List<int>();
    115      
    116       for(int row = 0; row < preprocessingData.Rows; ++row) {
     124
     125      for (int row = 0; row < preprocessingData.Rows; ++row) {
    117126        if (IsMissingValue(columnIndex, row)) {
    118127          missingIndices.Add(row);
     
    123132    }
    124133
    125     public IEnumerable<T> GetValuesWithoutNaN<T>(int columnIndex, bool considerSelection)
    126     {
    127       if (considerSelection) {     
    128         var selectedRows =  preprocessingData.Selection[columnIndex];
    129        
     134    public IEnumerable<T> GetValuesWithoutNaN<T>(int columnIndex, bool considerSelection) {
     135      if (considerSelection) {
     136        var selectedRows = preprocessingData.Selection[columnIndex];
     137
    130138        List<T> values = new List<T>();
    131139        foreach (var rowIdx in selectedRows) {
  • branches/DataPreprocessingImprovements/HeuristicLab.DataPreprocessing/3.4/Implementations/StatisticsLogic.cs

    r12012 r12545  
    3838
    3939    public int GetColumnCount() {
    40       return preprocessingData.Columns;
     40      return searchLogic.Columns;
    4141    }
    4242
    4343    public int GetRowCount() {
    44       return preprocessingData.Rows;
     44      return searchLogic.Rows;
    4545    }
    4646
     
    4848      int count = 0;
    4949
    50       for (int i = 0; i < preprocessingData.Columns; ++i) {
     50      for (int i = 0; i < searchLogic.Columns; ++i) {
    5151        if (preprocessingData.VariableHasType<double>(i)) {
    5252          ++count;
     
    5757
    5858    public int GetNominalColumnCount() {
    59       return preprocessingData.Columns - GetNumericColumnCount();
     59      return searchLogic.Columns - GetNumericColumnCount();
    6060    }
    6161
    6262    public int GetMissingValueCount() {
    6363      int count = 0;
    64       for (int i = 0; i < preprocessingData.Columns; ++i) {
     64      for (int i = 0; i < searchLogic.Columns; ++i) {
    6565        count += GetMissingValueCount(i);
    6666      }
     
    7373
    7474    public T GetMin<T>(int columnIndex, bool considerSelection) where T : IComparable<T> {
    75       return preprocessingData.GetValues<T>(columnIndex, considerSelection).Min();
     75      var min = default(T);
     76      if (preprocessingData.VariableHasType<T>(columnIndex)) {
     77        var values = GetValuesWithoutNaN<T>(columnIndex, considerSelection);
     78        if (values.Any()) {
     79          min = values.Min();
     80        }
     81      }
     82      return min;
    7683    }
    7784
    7885    public T GetMax<T>(int columnIndex, bool considerSelection) where T : IComparable<T> {
    79       return preprocessingData.GetValues<T>(columnIndex, considerSelection).Max();
     86      var max = default(T);
     87      if (preprocessingData.VariableHasType<T>(columnIndex)) {
     88        var values = GetValuesWithoutNaN<T>(columnIndex, considerSelection);
     89        if (values.Any()) {
     90          max = values.Max();
     91        }
     92      }
     93      return max;
    8094    }
    8195
     
    8397      double median = double.NaN;
    8498      if (preprocessingData.VariableHasType<double>(columnIndex)) {
    85         median = GetValuesWithoutNaN<double>(columnIndex, considerSelection).Median();
     99        var values = GetValuesWithoutNaN<double>(columnIndex, considerSelection);
     100        if (values.Any()) {
     101          median = values.Median();
     102        }
    86103      }
    87104      return median;
     
    91108      double avg = double.NaN;
    92109      if (preprocessingData.VariableHasType<double>(columnIndex)) {
    93         avg = GetValuesWithoutNaN<double>(columnIndex, considerSelection).Average();
     110        var values = GetValuesWithoutNaN<double>(columnIndex, considerSelection);
     111        if (values.Any()) {
     112          avg = values.Average();
     113        }
    94114      }
    95115      return avg;
     
    113133
    114134    public T GetMostCommonValue<T>(int columnIndex, bool considerSelection) {
    115       var t = preprocessingData.GetValues<T>(columnIndex, considerSelection);
    116       var t2 = t.GroupBy(x => x);
    117       var t3 = t2.Select(g => g.Key);
    118 
    119       return preprocessingData.GetValues<T>(columnIndex, considerSelection)
    120                               .GroupBy(x => x)
     135      var values = GetValuesWithoutNaN<T>(columnIndex, considerSelection);
     136      if (!values.Any())
     137        return default(T);
     138      return values.GroupBy(x => x)
    121139                              .OrderByDescending(g => g.Count())
    122140                              .Select(g => g.Key)
Note: See TracChangeset for help on using the changeset viewer.