Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/HeuristicLab.DataPreprocessing-3.3.csproj
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/HeuristicLab.DataPreprocessing-3.3.csproj	(revision 10248)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/HeuristicLab.DataPreprocessing-3.3.csproj	(revision 10249)
@@ -87,5 +87,4 @@
     <Compile Include="Implementations\LineChartLogic.cs" />
     <Compile Include="Implementations\StatisticsContent.cs" />
-    <Compile Include="Implementations\StatisticsLogic.cs" />
     <Compile Include="Implementations\TransformationContent.cs" />
     <Compile Include="Implementations\TransformationLogic.cs" />
@@ -93,5 +92,4 @@
     <Compile Include="Interfaces\IHistogramLogic.cs" />
     <Compile Include="Interfaces\ILineChartLogic.cs" />
-    <Compile Include="Interfaces\IStatisticsLogic.cs" />
     <Compile Include="Interfaces\ITransformationLogic.cs" />
     <Compile Include="Views\DataPreprocessingView.cs">
@@ -107,5 +105,5 @@
     <Compile Include="Implementations\PreprocessingDataManipulation.cs" />
     <Compile Include="Implementations\SearchLogic.cs" />
-    <Compile Include="Implementations\StatisticInfo.cs" />
+    <Compile Include="Implementations\StatisticsLogic.cs" />
     <Compile Include="Views\DataGridContentView.cs">
       <SubType>UserControl</SubType>
@@ -117,5 +115,5 @@
     <Compile Include="Interfaces\IPreprocessingContext.cs" />
     <Compile Include="Interfaces\ISearchLogic.cs" />
-    <Compile Include="Interfaces\IStatisticInfo.cs" />
+    <Compile Include="Interfaces\IStatisticsLogic.cs" />
     <Compile Include="Interfaces\IPreprocessingData.cs" />
     <Compile Include="Plugin.cs" />
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingDataManipulation.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingDataManipulation.cs	(revision 10248)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingDataManipulation.cs	(revision 10249)
@@ -1,177 +1,143 @@
-﻿using HeuristicLab.Data;
-using System;
+﻿using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using HeuristicLab.Data;
 
-namespace HeuristicLab.DataPreprocessing
-{
-    class PreprocessingDataManipulation : IPreprocessingDataManipulation
-    {
-        private IPreprocessingData preprocessingData;
-        private StatisticInfo statisticInfo;
-        private ISearchLogic searchLogic;
+namespace HeuristicLab.DataPreprocessing {
+  class PreprocessingDataManipulation : IPreprocessingDataManipulation {
+    private IPreprocessingData preprocessingData;
+    private IStatisticsLogic statisticInfo;
+    private ISearchLogic searchLogic;
 
-        public PreprocessingDataManipulation(IPreprocessingData _prepocessingData) {
-            preprocessingData = _prepocessingData;
-          //todo 
-            searchLogic = new SearchLogic(preprocessingData);
-            statisticInfo = new StatisticInfo(preprocessingData,searchLogic);
-            
+    public PreprocessingDataManipulation(IPreprocessingData _prepocessingData, ISearchLogic theSearchLogic, IStatisticsLogic theStatisticsLogic) {
+      preprocessingData = _prepocessingData;
+      searchLogic = theSearchLogic;
+      statisticInfo = theStatisticsLogic;
+    }
+
+    public void ReplaceIndicesByValue<T>(string variableName, IEnumerable<int> indices, T value) {
+      foreach (int index in indices) {
+        preprocessingData.SetCell<T>(variableName, index, value);
+      }
+    }
+
+    public void ReplaceIndicesByAverageValue(string variableName, IEnumerable<int> indices) {
+      double average = statisticInfo.GetAverage(variableName);
+      ReplaceIndicesByValue<double>(variableName, indices, average);
+    }
+
+    public void ReplaceIndicesByMedianValue(string variableName, IEnumerable<int> indices) {
+      double median = statisticInfo.GetMedian(variableName);
+      ReplaceIndicesByValue<double>(variableName, indices, median);
+    }
+
+    public void ReplaceIndicesByRandomValue(string variableName, IEnumerable<int> indices) {
+      Random r = new Random();
+
+      double max = statisticInfo.GetMax<double>(variableName);
+      double min = statisticInfo.GetMin<double>(variableName);
+      double randMultiplier = (max - min);
+      foreach (int index in indices) {
+        double rand = r.NextDouble() * randMultiplier + min;
+        preprocessingData.SetCell<double>(variableName, index, rand);
+      }
+    }
+
+    public void ReplaceIndicesByLinearInterpolationOfNeighbours(string variableName, IEnumerable<int> indices) {
+      int countValues = preprocessingData.GetValues<double>(variableName).Count();
+      foreach (int index in indices) {
+        // dont replace first or last values
+        if (index > 0 && index < countValues) {
+          int prevIndex = indexOfPrevPresentValue(variableName, index);
+          int nextIndex = indexOfNextPresentValue(variableName, index);
+
+          // no neighbours found
+          if (prevIndex < 0 && nextIndex >= countValues) {
+            continue;
+          }
+          double prev = preprocessingData.GetCell<double>(variableName, prevIndex);
+          double next = preprocessingData.GetCell<double>(variableName, nextIndex);
+
+          int valuesToInterpolate = nextIndex - prevIndex;
+
+          double interpolationStep = (prev + next) / valuesToInterpolate;
+
+          for (int i = prevIndex; i < nextIndex; ++i) {
+            double interpolated = prev + (interpolationStep * (i - prevIndex));
+            preprocessingData.SetCell<double>(variableName, i, interpolated);
+          }
+        }
+      }
+    }
+
+    private int indexOfPrevPresentValue(string variableName, int start) {
+      int offset = start - 1;
+      while (offset >= 0 && searchLogic.IsMissingValue(variableName, offset)) {
+        offset--;
+      }
+
+      return offset;
+    }
+
+    private int indexOfNextPresentValue(string variableName, int start) {
+      int offset = start + 1;
+      while (offset < preprocessingData.Rows && searchLogic.IsMissingValue(variableName, offset)) {
+        offset++;
+      }
+
+      return offset;
+    }
+
+    public void ReplaceIndicesByMostCommonValue(string variableName, IEnumerable<int> indices) {
+      if (preprocessingData.IsType<double>(variableName)) {
+        ReplaceIndicesByValue<double>(variableName, indices, statisticInfo.GetMostCommonValue<double>(variableName));
+      } else if (preprocessingData.IsType<string>(variableName)) {
+        ReplaceIndicesByValue<string>(variableName, indices, statisticInfo.GetMostCommonValue<string>(variableName));
+      } else if (preprocessingData.IsType<DateTime>(variableName)) {
+        ReplaceIndicesByValue<DateTime>(variableName, indices, statisticInfo.GetMostCommonValue<DateTime>(variableName));
+      } else {
+        throw new ArgumentException("column with index: " + variableName + " contains a non supported type.");
+      }
+    }
+
+    public void ShuffleWithRanges(IEnumerable<IntRange> ranges) {
+      // init random outside loop
+      Random random = new Random();
+
+      // process all given ranges - e.g. TrainingPartition, Trainingpartition
+      foreach (IntRange range in ranges) {
+        List<Tuple<int, int>> shuffledIndices = new List<Tuple<int, int>>();
+
+        // generate random indices used for shuffeling each column
+        for (int i = range.End; i > range.Start; --i) {
+          int rand = random.Next(range.Start, i);
+          shuffledIndices.Add(new Tuple<int, int>(i, rand));
         }
 
-        public void ReplaceIndicesByValue<T>(string variableName, IEnumerable<int> indices, T value)
-        {
-            foreach (int index in indices)
-            {
-                preprocessingData.SetCell<T>(variableName, index, value);
-            }
+        foreach (string variableName in preprocessingData.VariableNames) {
+          if (preprocessingData.IsType<double>(variableName)) {
+            reOrderToIndices<double>(variableName, shuffledIndices);
+          } else if (preprocessingData.IsType<string>(variableName)) {
+            reOrderToIndices<string>(variableName, shuffledIndices);
+          } else if (preprocessingData.IsType<DateTime>(variableName)) {
+            reOrderToIndices<DateTime>(variableName, shuffledIndices);
+          }
         }
+      }
+    }
 
-        public void ReplaceIndicesByAverageValue(string variableName, IEnumerable<int> indices)
-        {
-            double average = statisticInfo.GetAverage(variableName);
-            ReplaceIndicesByValue<double>(variableName, indices, average);
-        }
+    public void reOrderToIndices<T>(string variableName, List<Tuple<int, int>> indices) {
+      // process all columns equally
+      foreach (Tuple<int, int> index in indices) {
+        int originalIndex = index.Item1;
+        int replaceIndex = index.Item2;
 
-        public void ReplaceIndicesByMedianValue(string variableName, IEnumerable<int> indices)
-        {
-            double median = statisticInfo.GetMedian(variableName);
-            ReplaceIndicesByValue<double>(variableName, indices, median);
-        }
+        T tmp = preprocessingData.GetCell<T>(variableName, originalIndex);
+        T replaceValue = preprocessingData.GetCell<T>(variableName, replaceIndex);
 
-        public void ReplaceIndicesByRandomValue(string variableName, IEnumerable<int> indices)
-        {
-            Random r = new Random();
-
-            double max = statisticInfo.GetMax<double>(variableName);
-            double min = statisticInfo.GetMin<double>(variableName);
-            double randMultiplier = (max - min);
-            foreach (int index in indices)
-            {
-                double rand = r.NextDouble() * randMultiplier + min;
-                preprocessingData.SetCell<double>(variableName, index, rand);
-            }
-        }
-
-        public void ReplaceIndicesByLinearInterpolationOfNeighbours(string variableName, IEnumerable<int> indices)
-        {
-            int countValues = preprocessingData.GetValues<double>(variableName).Count();
-            foreach (int index in indices)
-            {
-                // dont replace first or last values
-                if (index > 0 && index < countValues)
-                {
-                    int prevIndex = indexOfPrevPresentValue(variableName, index);
-                    int nextIndex = indexOfNextPresentValue(variableName, index);
-
-                    // no neighbours found
-                    if (prevIndex < 0 && nextIndex >= countValues)
-                    {
-                        continue;
-                    }
-                    double prev = preprocessingData.GetCell<double>(variableName, prevIndex);
-                    double next = preprocessingData.GetCell<double>(variableName, nextIndex);
-
-                    int valuesToInterpolate = nextIndex - prevIndex;
-
-                    double interpolationStep = (prev + next) / valuesToInterpolate;
-
-                    for (int i = prevIndex; i < nextIndex; ++i) {
-                        double interpolated = prev + (interpolationStep * (i-prevIndex));
-                        preprocessingData.SetCell<double>(variableName, i, interpolated);
-                    }
-                }
-            }
-        }
-
-        private int indexOfPrevPresentValue(string variableName, int start) {
-            int offset = start - 1;
-            while (offset >= 0 && searchLogic.IsMissingValue(variableName, offset)) {
-                offset--;
-            }
-
-            return offset;
-        }
-
-        private int indexOfNextPresentValue(string variableName, int start)
-        {
-            int offset = start + 1;
-            while (offset < preprocessingData.Rows && searchLogic.IsMissingValue(variableName, offset))
-            {
-                offset++;
-            }
-
-            return offset;
-        }
-
-        public void ReplaceIndicesByMostCommonValue(string variableName, IEnumerable<int> indices)
-        {
-            if (preprocessingData.IsType<double>(variableName))
-            {
-                ReplaceIndicesByValue<double>(variableName, indices, statisticInfo.GetMostCommonValue<double>(variableName));
-            }
-            else if (preprocessingData.IsType<string>(variableName))
-            {
-                ReplaceIndicesByValue<string>(variableName, indices, statisticInfo.GetMostCommonValue<string>(variableName));
-            }
-            else if (preprocessingData.IsType<DateTime>(variableName))
-            {
-                ReplaceIndicesByValue<DateTime>(variableName, indices, statisticInfo.GetMostCommonValue<DateTime>(variableName));
-            }
-            else
-            {
-                throw new ArgumentException("column with index: " + variableName + " contains a non supported type.");
-            }
-        }
-
-        public void ShuffleWithRanges(IEnumerable<IntRange> ranges)
-        {
-            // init random outside loop
-            Random random = new Random();
-
-            // process all given ranges - e.g. TrainingPartition, Trainingpartition
-            foreach (IntRange range in ranges) { 
-                List<Tuple<int, int>> shuffledIndices = new List<Tuple<int,int>>();
-               
-                // generate random indices used for shuffeling each column
-                for (int i = range.End; i > range.Start; --i)
-                {
-                    int rand = random.Next(range.Start, i);
-                    shuffledIndices.Add(new Tuple<int,int>(i,rand));
-                }
-
-                foreach (string variableName in preprocessingData.VariableNames)
-                {
-                    if (preprocessingData.IsType<double>(variableName))
-                    {
-                        reOrderToIndices<double>(variableName, shuffledIndices);
-                    }
-                    else if (preprocessingData.IsType<string>(variableName))
-                    {
-                        reOrderToIndices<string>(variableName, shuffledIndices);
-                    }
-                    else if (preprocessingData.IsType<DateTime>(variableName))
-                    {
-                        reOrderToIndices<DateTime>(variableName, shuffledIndices);
-                    }
-                }
-            }      
-        }
-
-        public void reOrderToIndices<T>(string variableName, List<Tuple<int, int>> indices) {
-            // process all columns equally
-            foreach(Tuple<int, int> index in indices)
-            {
-                int originalIndex = index.Item1;
-                int replaceIndex = index.Item2;
-
-                T tmp = preprocessingData.GetCell<T>(variableName, originalIndex);
-                T replaceValue = preprocessingData.GetCell<T>(variableName, replaceIndex);
-
-                preprocessingData.SetCell<T>(variableName, originalIndex, replaceValue);
-                preprocessingData.SetCell<T>(variableName, replaceIndex, tmp);
-            }
-        }
+        preprocessingData.SetCell<T>(variableName, originalIndex, replaceValue);
+        preprocessingData.SetCell<T>(variableName, replaceIndex, tmp);
+      }
     }
+  }
 }
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticInfo.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticInfo.cs	(revision 10248)
+++ 	(revision )
@@ -1,114 +1,0 @@
-﻿using System;
-using System.Linq;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.DataPreprocessing {
-
-  public class StatisticInfo : IStatisticInfo {
-
-    private readonly IPreprocessingData preprocessingData;
-    private readonly ISearchLogic searchLogic;
-
-    public StatisticInfo(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;
-    }
-  }
-}
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsLogic.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsLogic.cs	(revision 10248)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsLogic.cs	(revision 10249)
@@ -1,11 +1,114 @@
 ﻿using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using HeuristicLab.Common;
 
-namespace HeuristicLab.DataPreprocessing.Implementations
-{
-  public class StatisticsLogic: IStatisticsLogic
-  {
+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;
+    }
   }
 }
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/TransformationLogic.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/TransformationLogic.cs	(revision 10248)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/TransformationLogic.cs	(revision 10249)
@@ -1,11 +1,5 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace HeuristicLab.DataPreprocessing.Implementations
-{
-  public class TransformationLogic : ITransformationLogic
-  {
+﻿
+namespace HeuristicLab.DataPreprocessing {
+  public class TransformationLogic : ITransformationLogic {
   }
 }
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticInfo.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticInfo.cs	(revision 10248)
+++ 	(revision )
@@ -1,22 +1,0 @@
-﻿using System;
-
-namespace HeuristicLab.DataPreprocessing {
-  public interface IStatisticInfo {
-
-    int GetColumnCount();
-    int GetRowCount();
-    int GetNumericColumnCount();
-    int GetNominalColumnCount();
-    int GetMissingValueCount();
-    int GetMissingValueCount(string variableName);
-    int GetRowMissingValueCount(int rowIndex);
-    T GetMin<T>(string variableName) where T : IComparable<T>;
-    T GetMax<T>(string variableName) where T : IComparable<T>;
-    double GetMedian(string variableName);
-    double GetAverage(string variableName);
-    T GetMostCommonValue<T>(string variableName);
-    double GetStandardDeviation(string variableName);
-    double GetVariance(string variableName);
-    int GetDifferentValuesCount<T>(string variableName);
-  }
-}
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticsLogic.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticsLogic.cs	(revision 10248)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IStatisticsLogic.cs	(revision 10249)
@@ -1,9 +1,22 @@
 ﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace HeuristicLab.DataPreprocessing {
   public interface IStatisticsLogic {
+
+    int GetColumnCount();
+    int GetRowCount();
+    int GetNumericColumnCount();
+    int GetNominalColumnCount();
+    int GetMissingValueCount();
+    int GetMissingValueCount(string variableName);
+    int GetRowMissingValueCount(int rowIndex);
+    T GetMin<T>(string variableName) where T : IComparable<T>;
+    T GetMax<T>(string variableName) where T : IComparable<T>;
+    double GetMedian(string variableName);
+    double GetAverage(string variableName);
+    T GetMostCommonValue<T>(string variableName);
+    double GetStandardDeviation(string variableName);
+    double GetVariance(string variableName);
+    int GetDifferentValuesCount<T>(string variableName);
   }
 }
