Changeset 10978 for branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4

Timestamp:

06/11/14 12:36:39 (10 years ago)

Author:

mleitner

Message:

Refactoring

Location:

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4

Files:

• Implementations/ChartLogic.cs (modified) (1 diff)
• Implementations/CorrelationMatrixContent.cs (modified) (2 diffs)
• Implementations/DataGridLogic.cs (modified) (1 diff)
• Implementations/FilteredPreprocessingData.cs (modified) (6 diffs)
• Implementations/PreprocessingContext.cs (modified) (2 diffs)
• Implementations/PreprocessingData.cs (modified) (8 diffs)
• Implementations/SearchLogic.cs (modified) (1 diff)
• Implementations/TransactionalPreprocessingData.cs (modified) (3 diffs)
• Interfaces/IPreprocessingContext.cs (modified) (1 diff)
• Interfaces/IPreprocessingData.cs (modified) (1 diff)

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/ChartLogic.cs

@@ -140 +140 @@
     public DataRow CreateSelectedDataRow(string variableName, DataRowVisualProperties.DataRowChartType chartType) {
       
-      IDictionary<int,IList<int>> selection = preprocessingData.GetSelection();
+      IDictionary<int,IList<int>> selection = preprocessingData.Selection;
       int variableIndex = preprocessingData.GetColumnIndex(variableName);
 

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/CorrelationMatrixContent.cs

@@ -26 +26 @@
 
 namespace HeuristicLab.DataPreprocessing {
-
   [Item("Feature Correlation Matrix", "Represents the feature correlation matrix.")]
   public class CorrelationMatrixContent : Item, IViewChartShortcut {
+    public static new Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Gradient; }
+    }
+
+    private IPreprocessingContext Context { get; set; }
+    private ITransactionalPreprocessingData PreprocessingData {
+      get { return Context.Data; }
+    }
 
     public DataAnalysisProblemData ProblemData {
@@ -34 +41 @@
         var creator = new ProblemDataCreator(Context);
         return (DataAnalysisProblemData)creator.CreateProblemData();
-      } 
+      }
     }
 
-    public ITransactionalPreprocessingData PreprocessingData { 
-      get {
-        return Context.Data;
-      } 
-    }
-
-    private IPreprocessingContext Context { get; set; }
     public CorrelationMatrixContent(IPreprocessingContext context) {
       Context = context;
-
-
     }
 
     public CorrelationMatrixContent(CorrelationMatrixContent original, Cloner cloner)
       : base(original, cloner) {
-
     }
-
-    public static new Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Gradient; }
-    }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new CorrelationMatrixContent(this, cloner);

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/DataGridLogic.cs

@@ -144 +144 @@
 
 
-
     public void SetSelection(IDictionary<int, IList<int>> selection) {
-      preprocessingData.SetSelection(selection);
+      preprocessingData.Selection = selection;
     }
 
     public IDictionary<int, IList<int>> GetSelection() {
-      return preprocessingData.GetSelection();
+      return preprocessingData.Selection;
     }
     public void ClearSelection() {

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/FilteredPreprocessingData.cs

@@ -10 +10 @@
 namespace HeuristicLab.DataPreprocessing.Implementations {
   public class FilteredPreprocessingData : NamedItem, IFilteredPreprocessingData {
-    protected ITransactionalPreprocessingData originalData;
-    protected ITransactionalPreprocessingData filteredData;
+    private readonly ITransactionalPreprocessingData originalData;
+    private ITransactionalPreprocessingData filteredData;
+
+     public IDictionary<int, IList<int>> Selection {
+      get { return originalData.Selection; }
+      set { originalData.Selection = value; }
+    }
 
     protected FilteredPreprocessingData(FilteredPreprocessingData original, Cloner cloner)
       : base(original, cloner) {
-      originalData = (ITransactionalPreprocessingData)original.originalData;
-      filteredData = (ITransactionalPreprocessingData)original.filteredData;
+      originalData = original.originalData;
+      filteredData = original.filteredData;
     }
 
@@ -34 +39 @@
 
     public void SetCell<T>(int columnIndex, int rowIndex, T value) {
-      ReadOnlyOnFilterData.SetCell<T>(columnIndex, rowIndex, value);
+      if (IsFiltered)
+        throw new InvalidOperationException("SetCell not possible while data is filtered");
+
+      originalData.SetCell<T>(columnIndex, rowIndex, value);
     }
 
@@ -50 +58 @@
 
     public void SetValues<T>(int columnIndex, IList<T> values) {
-      ReadOnlyOnFilterData.SetValues<T>(columnIndex, values);
+      if (IsFiltered)
+        throw new InvalidOperationException("SetValues not possible while data is filtered");
+
+      originalData.SetValues<T>(columnIndex, values);
     }
 
     public void InsertRow(int rowIndex) {
-      ReadOnlyOnFilterData.InsertRow(rowIndex);
+      if (IsFiltered)
+        throw new InvalidOperationException("InsertRow not possible while data is filtered");
+
+      originalData.InsertRow(rowIndex);
     }
 
     public void DeleteRow(int rowIndex) {
-      ReadOnlyOnFilterData.DeleteRow(rowIndex);
+      if (IsFiltered)
+        throw new InvalidOperationException("DeleteRow not possible while data is filtered");
+
+      originalData.DeleteRow(rowIndex);
     }
 
     public void InsertColumn<T>(string variableName, int columnIndex) {
-      ReadOnlyOnFilterData.InsertColumn<T>(variableName, columnIndex);
+      if (IsFiltered)
+        throw new InvalidOperationException("InsertColumn not possible while data is filtered");
+
+      originalData.InsertColumn<T>(variableName, columnIndex);
     }
 
     public void DeleteColumn(int columnIndex) {
-      ReadOnlyOnFilterData.DeleteColumn(columnIndex);
+      if (IsFiltered)
+        throw new InvalidOperationException("DeleteColumn not possible while data is filtered");
+      originalData.DeleteColumn(columnIndex);
     }
 
@@ -153 +175 @@
     }
 
-    public ITransactionalPreprocessingData ReadOnlyOnFilterData {
-      get {
-        if (IsFiltered)
-          throw new InvalidOperationException();
-
-        return originalData;
-      }
-    }
+
+    public bool IsUndoAvailable {
+      get { return IsFiltered ? false : originalData.IsUndoAvailable; }
+    }
+
 
     public bool IsFiltered {
@@ -171 +190 @@
     }
 
-    public bool IsUndoAvailable {
-      get { return IsFiltered ? false : originalData.IsUndoAvailable; }
-    }
 
     public void Undo() {
-      ReadOnlyOnFilterData.Undo();
+      if (IsFiltered)
+        throw new InvalidOperationException("Undo not possible while data is filtered");
+
+      originalData.Undo();
     }
 
     public void InTransaction(Action action, DataPreprocessingChangedEventType type = DataPreprocessingChangedEventType.Any) {
-      ReadOnlyOnFilterData.InTransaction(action, type);
+      if (IsFiltered)
+        throw new InvalidOperationException("Transaction not possible while data is filtered");
+      originalData.InTransaction(action, type);
     }
 
     public void BeginTransaction(DataPreprocessingChangedEventType type) {
-      ReadOnlyOnFilterData.BeginTransaction(type);
+      if (IsFiltered)
+        throw new InvalidOperationException("Transaction not possible while data is filtered");
+      originalData.BeginTransaction(type);
     }
 
@@ -194 +217 @@
 
     #region IPreprocessingData Members
-
-
-    public void SetSelection(IDictionary<int, IList<int>> selection) {
-      originalData.SetSelection(selection);
-    }
-
-    public IDictionary<int, IList<int>> GetSelection() {
-      return originalData.GetSelection();
-    }
 
     public void ClearSelection() {

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingContext.cs

@@ -34 +34 @@
 
     public IFilteredPreprocessingData Data { get; private set; }
-
-    public IDataAnalysisProblemData DataAnalysisProblemData { get; private set; }
-
     public IAlgorithm Algorithm { get; private set; }
-
     public IDataAnalysisProblem Problem { get; private set; }
 
     public PreprocessingContext(IDataAnalysisProblemData dataAnalysisProblemData, IAlgorithm algorithm, IDataAnalysisProblem problem) {
-
       TransactionalPreprocessingData transactionalPreprocessingData = new TransactionalPreprocessingData(dataAnalysisProblemData);
 
       Data = new FilteredPreprocessingData(transactionalPreprocessingData);
-      DataAnalysisProblemData = dataAnalysisProblemData;
       Algorithm = algorithm;
       Problem = problem;
@@ -54 +48 @@
       : base(original, cloner) {
       Data = cloner.Clone(original.Data);
-      DataAnalysisProblemData = original.DataAnalysisProblemData;
       Algorithm = original.Algorithm;
       Problem = original.Problem;

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingData.cs

@@ -33 +33 @@
 
   [Item("PreprocessingData", "Represents data used for preprocessing.")]
-  public class PreprocessingData : NamedItem, IPreprocessingData {
+  public abstract class PreprocessingData : NamedItem, IPreprocessingData {
+
+    protected double trainingToTestRatio;
+    public IntRange TrainingPartition {
+      get { return new IntRange(0, (int)(Rows * trainingToTestRatio)); }
+    }
+    public IntRange TestPartition {
+      get { return new IntRange((int)(Rows * trainingToTestRatio), Rows); }
+    }
+
+    protected IList<ITransformation> transformations;
+    public IList<ITransformation> Transformations {
+      get { return transformations; }
+    }
 
     protected IList<IList> variableValues;
-
     protected IList<string> variableNames;
 
-    protected double trainingToTestRatio;
-
-    protected IList<ITransformation> transformations;
-
-    protected IDictionary<int, IList<int>> currentSelection;
+    public IEnumerable<string> VariableNames {
+      get { return variableNames; }
+    }
+
+    public int Columns {
+      get { return variableNames.Count; }
+    }
+
+    public int Rows {
+      get { return variableValues.Count > 0 ? variableValues[0].Count : 0; }
+    }
+
+    protected IDictionary<int, IList<int>> selection;
+    public IDictionary<int, IList<int>> Selection {
+      get { return selection; }
+      set {
+          selection = value;
+          OnSelectionChanged();
+        }
+      }    
 
     protected PreprocessingData(PreprocessingData original, Cloner cloner)
@@ -53 +80 @@
     }
 
-    public PreprocessingData(IDataAnalysisProblemData problemData)
+    protected PreprocessingData(IDataAnalysisProblemData problemData)
       : base() {
       Name = "Preprocessing Data";
 
       transformations = new List<ITransformation>();
-      currentSelection = new Dictionary<int, IList<int>>();
+      selection = new Dictionary<int, IList<int>>();
 
       variableNames = new List<string>(problemData.Dataset.VariableNames);
-      // create dictionary from variable name to index
 
       int columnIndex = 0;
@@ -73 +99 @@
           variableValues.Insert(columnIndex, CreateColumn<DateTime>(problemData.Dataset, columnIndex, x => DateTime.Parse(x)));
         } else {
-          throw new ArgumentException("The datatype of column " + variableName + " must be of type List<double>, List<string> or List<DateTime>");
+          throw new ArgumentException("The datatype of column " + variableName + " must be of type double, string or DateTime");
         }
         ++columnIndex;
@@ -97 +123 @@
     }
 
-    #region NamedItem abstract Member Implementations
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PreprocessingData(this, cloner);
-    }
-
-    #endregion
 
     #region IPreprocessingData Members
@@ -111 +130 @@
     }
 
-
     public virtual void SetCell<T>(int columnIndex, int rowIndex, T value) {
       variableValues[columnIndex][rowIndex] = value;
     }
 
-
     public string GetCellAsString(int columnIndex, int rowIndex) {
       return variableValues[columnIndex][rowIndex].ToString();
     }
 
+    public string GetVariableName(int columnIndex) {
+      return variableNames[columnIndex];
+    }
+
+    public int GetColumnIndex(string variableName) {
+      return variableNames.IndexOf(variableName);
+    }
+
+    public bool IsType<T>(int columnIndex) {
+      return variableValues[columnIndex] is List<T>;
+    }
 
     [Obsolete("use the index based variant, is faster")]
@@ -130 +158 @@
       if (considerSelection) {
         var list = new List<T>();
-        foreach (var rowIdx in currentSelection[columnIndex]) {
+        foreach (var rowIdx in selection[columnIndex]) {
           list.Add((T)variableValues[columnIndex][rowIdx]);
         }
@@ -170 +198 @@
     }
 
-    public IntRange TrainingPartition {
-      get { return new IntRange(0, (int)(Rows * trainingToTestRatio)); }
-    }
-
-    public IntRange TestPartition {
-      get { return new IntRange((int)(Rows * trainingToTestRatio), Rows); }
-    }
-
-    public IList<ITransformation> Transformations {
-      get { return transformations; }
-    }
-
-    public string GetVariableName(int columnIndex) {
-      return variableNames[columnIndex];
-    }
-
-    public IEnumerable<string> VariableNames {
-      get { return variableNames; }
-    }
-
-    public int GetColumnIndex(string variableName) {
-      return variableNames.IndexOf(variableName);
-    }
-
-    public bool IsType<T>(int columnIndex) {
-      return variableValues[columnIndex] is List<T>;
-    }
-
-    public int Columns {
-      get { return variableNames.Count; }
-    }
-
-    public int Rows {
-      get { return variableValues.Count > 0 ? variableValues[0].Count : 0; }
-    }
-
     public Dataset ExportToDataset() {
       IList<IList> values = new List<IList>();
@@ -217 +209 @@
     }
 
-    public void SetSelection(IDictionary<int, IList<int>> selection) {
-      currentSelection = selection;
-      if (SelectionChanged != null) {
-        SelectionChanged(this, new EventArgs());
-      }
-    }
-
-    public IDictionary<int, IList<int>> GetSelection() {
-      return currentSelection;
-    }
-
     public void ClearSelection() {
-      currentSelection = new Dictionary<int, IList<int>>();
+      Selection = new Dictionary<int, IList<int>>();
     }
 
     public event EventHandler SelectionChanged;
-
+    protected virtual void OnSelectionChanged() { 
+       var listeners = SelectionChanged;
+       if (listeners != null) listeners(this, EventArgs.Empty);
+    }
+
+    public event DataPreprocessingChangedEventHandler Changed;
+    protected virtual void OnChanged(DataPreprocessingChangedEventType type, int column, int row) {
+      var listeners = Changed;
+      if (listeners != null) listeners(this, new DataPreprocessingChangedEventArgs(type, column, row));
+    }
     #endregion
   }

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/SearchLogic.cs

@@ -114 +114 @@
     {
       if (considerSelection) {     
-        var selectedRows =  preprocessingData.GetSelection()[columnIndex];
+        var selectedRows =  preprocessingData.Selection[columnIndex];
         
         List<T> values = new List<T>();

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/TransactionalPreprocessingData.cs

@@ -30 +30 @@
 namespace HeuristicLab.DataPreprocessing {
 
-  internal class Snapshot {
-    public IList<IList> VariableValues { get; set; }
-
-    public IList<string> VariableNames { get; set; }
-
-    public double TrainingToTestRatio { get; set; }
-
-    public IList<ITransformation> Transformations { get; set; }
-
-    public DataPreprocessingChangedEventType ChangedType { get; set; }
-
-    public int ChangedColumn { get; set; }
-
-    public int ChangedRow { get; set; }
-  }
-
   [Item("PreprocessingData", "Represents data used for preprocessing.")]
   public class TransactionalPreprocessingData : PreprocessingData, ITransactionalPreprocessingData {
 
+    private class Snapshot {
+      public IList<IList> VariableValues { get; set; }
+      public IList<string> VariableNames { get; set; }
+
+      public double TrainingToTestRatio { get; set; }
+      public IList<ITransformation> Transformations { get; set; }
+      public DataPreprocessingChangedEventType ChangedType { get; set; }
+
+      public int ChangedColumn { get; set; }
+      public int ChangedRow { get; set; }
+    }
+
     private const int MAX_UNDO_DEPTH = 5;
 
-    private IList<Snapshot> undoHistory;
-
-    private Stack<DataPreprocessingChangedEventType> eventStack = new Stack<DataPreprocessingChangedEventType>();
-
-    private DataPreprocessingChangedEventType lastOccuredChangedType = DataPreprocessingChangedEventType.Any;
+    private readonly IList<Snapshot> undoHistory = new List<Snapshot>();
+    private readonly Stack<DataPreprocessingChangedEventType> eventStack = new Stack<DataPreprocessingChangedEventType>();
 
     public bool IsInTransaction { get { return eventStack.Count > 0; } }
@@ -61 +54 @@
     public TransactionalPreprocessingData(IDataAnalysisProblemData problemData)
       : base(problemData) {
-      undoHistory = new List<Snapshot>();
     }
 
     private TransactionalPreprocessingData(TransactionalPreprocessingData original, Cloner cloner)
       : base(original, cloner) {
-      undoHistory = new List<Snapshot>();
-    }
+     }
 
     private void SaveSnapshot(DataPreprocessingChangedEventType changedType, int column, int row) {
-      if (eventStack.Count > 0) return;
+      if (IsInTransaction) return;
 
       var currentSnapshot = new Snapshot {
@@ -144 +135 @@
     #region TransactionalPreprocessingData members
 
-    public event DataPreprocessingChangedEventHandler Changed;
-    protected virtual void OnChanged(DataPreprocessingChangedEventType type, int column, int row) {
-      var listeners = Changed;
-      if (listeners != null) listeners(this, new DataPreprocessingChangedEventArgs(type, column, row));
-    }
-
     public bool IsUndoAvailable {
       get { return undoHistory.Count > 0; }

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Interfaces/IPreprocessingContext.cs

@@ -27 +27 @@
 
 namespace HeuristicLab.DataPreprocessing {
-  public interface IPreprocessingContext
-    : IItem {
+  public interface IPreprocessingContext : IItem {
 
     IFilteredPreprocessingData Data { get; }
-
-    [Obsolete]
-    IDataAnalysisProblemData DataAnalysisProblemData { get; }
-
     IAlgorithm Algorithm { get; }
-
     IDataAnalysisProblem Problem { get; }
 
     IItem ExportAlgorithmOrProblem();
-
     IAlgorithm ExportAlgorithm();
-
     IProblem ExportProblem();
   }

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Interfaces/IPreprocessingData.cs

@@ -65 +65 @@
     Dataset ExportToDataset();
 
-    void SetSelection(IDictionary<int, IList<int>> selection);
-    IDictionary<int, IList<int>> GetSelection();
+    IDictionary<int, IList<int>> Selection { get; set; }
     void ClearSelection();