Index: /trunk/sources/HeuristicLab.DataPreprocessing.Views/3.4/ComparisonFilterView.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing.Views/3.4/ComparisonFilterView.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing.Views/3.4/ComparisonFilterView.cs	(revision 11156)
@@ -158,9 +158,9 @@
     private IStringConvertibleValue CreateStringConvertibleValue(int columnIndex) {
       IStringConvertibleValue value;
-      if (Content.ConstrainedValue.IsType<double>(columnIndex)) {
+      if (Content.ConstrainedValue.VariableHasType<double>(columnIndex)) {
         value = new DoubleValue();
-      } else if (Content.ConstrainedValue.IsType<String>(columnIndex)) {
+      } else if (Content.ConstrainedValue.VariableHasType<String>(columnIndex)) {
         value = new StringValue();
-      } else if (Content.ConstrainedValue.IsType<DateTime>(columnIndex)) {
+      } else if (Content.ConstrainedValue.VariableHasType<DateTime>(columnIndex)) {
         value = new DateTimeValue();
       } else {
Index: /trunk/sources/HeuristicLab.DataPreprocessing.Views/3.4/DataGridContentView.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing.Views/3.4/DataGridContentView.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing.Views/3.4/DataGridContentView.cs	(revision 11156)
@@ -358,9 +358,9 @@
       IPreprocessingData preprocessingData = Content.FilterLogic.PreprocessingData;
       IStringConvertibleValue value;
-      if (preprocessingData.IsType<double>(columnIndex)) {
+      if (preprocessingData.VariableHasType<double>(columnIndex)) {
         value = new DoubleValue();
-      } else if (preprocessingData.IsType<String>(columnIndex)) {
+      } else if (preprocessingData.VariableHasType<String>(columnIndex)) {
         value = new StringValue();
-      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+      } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
         value = new DateTimeValue();
       } else {
Index: /trunk/sources/HeuristicLab.DataPreprocessing.Views/3.4/StatisticsView.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing.Views/3.4/StatisticsView.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing.Views/3.4/StatisticsView.cs	(revision 11156)
@@ -124,9 +124,9 @@
       List<string> list;
       var logic = Content.StatisticsLogic;
-      if (logic.IsType<double>(i)) {
+      if (logic.VariableHasType<double>(i)) {
         list = GetDoubleColumns(i);
-      } else if (logic.IsType<string>(i)) {
+      } else if (logic.VariableHasType<string>(i)) {
         list = GetStringColumns(i);
-      } else if (logic.IsType<DateTime>(i)) {
+      } else if (logic.VariableHasType<DateTime>(i)) {
         list = GetDateTimeColumns(i);
       } else {
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/Filter/ComparisonFilter.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/Filter/ComparisonFilter.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/Filter/ComparisonFilter.cs	(revision 11156)
@@ -95,7 +95,7 @@
       for (int row = 0; row < ConstrainedValue.Rows; ++row) {
         object item = null;
-        if (ConstrainedValue.IsType<double>(constraintColumn)) {
+        if (ConstrainedValue.VariableHasType<double>(constraintColumn)) {
           item = new HeuristicLab.Data.DoubleValue(ConstrainedValue.GetCell<double>(ConstraintColumn, row));
-        } else if (ConstrainedValue.IsType<DateTime>(constraintColumn)) {
+        } else if (ConstrainedValue.VariableHasType<DateTime>(constraintColumn)) {
           item = new HeuristicLab.Data.DateTimeValue(ConstrainedValue.GetCell<DateTime>(ConstraintColumn, row));
         } else {
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/FilteredPreprocessingData.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/FilteredPreprocessingData.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/FilteredPreprocessingData.cs	(revision 11156)
@@ -133,6 +133,6 @@
     }
 
-    public bool IsType<T>(int columnIndex) {
-      return originalData.IsType<T>(columnIndex);
+    public bool VariableHasType<T>(int columnIndex) {
+      return originalData.VariableHasType<T>(columnIndex);
     }
 
@@ -156,9 +156,9 @@
       originalData.InTransaction(() => {
         for (int i = 0; i < filteredData.Columns; ++i) {
-          if (filteredData.IsType<double>(i)) {
+          if (filteredData.VariableHasType<double>(i)) {
             originalData.SetValues<double>(i, filteredData.GetValues<double>(i));
-          } else if (filteredData.IsType<string>(i)) {
+          } else if (filteredData.VariableHasType<string>(i)) {
             originalData.SetValues<string>(i, filteredData.GetValues<string>(i));
-          } else if (filteredData.IsType<DateTime>(i)) {
+          } else if (filteredData.VariableHasType<DateTime>(i)) {
             originalData.SetValues<DateTime>(i, filteredData.GetValues<DateTime>(i));
           } else {
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/HistogramContent.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/HistogramContent.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/HistogramContent.cs	(revision 11156)
@@ -61,5 +61,5 @@
       //only return variable names from type double
       for (int i = 0; i < PreprocessingData.Columns; ++i) {
-        if (PreprocessingData.IsType<double>(i)) {
+        if (PreprocessingData.VariableHasType<double>(i)) {
           double distinctValueCount = PreprocessingData.GetValues<double>(i).GroupBy(x => x).Count();
           bool distinctValuesOk = distinctValueCount <= MAX_DISTINCT_VALUES_FOR_CLASSIFCATION;
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/ManipulationLogic.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/ManipulationLogic.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/ManipulationLogic.cs	(revision 11156)
@@ -54,8 +54,8 @@
       preprocessingData.InTransaction(() => {
         foreach (var column in cells) {
-          if (preprocessingData.IsType<double>(column.Key)) {
+          if (preprocessingData.VariableHasType<double>(column.Key)) {
             double average = statisticsLogic.GetAverage(column.Key, considerSelection);
             ReplaceIndicesByValue<double>(column.Key, column.Value, average);
-          } else if (preprocessingData.IsType<DateTime>(column.Key)) {
+          } else if (preprocessingData.VariableHasType<DateTime>(column.Key)) {
             DateTime average = statisticsLogic.GetAverageDateTime(column.Key, considerSelection);
             ReplaceIndicesByValue<DateTime>(column.Key, column.Value, average);
@@ -68,8 +68,8 @@
       preprocessingData.InTransaction(() => {
         foreach (var column in cells) {
-          if (preprocessingData.IsType<double>(column.Key)) {
+          if (preprocessingData.VariableHasType<double>(column.Key)) {
             double median = statisticsLogic.GetMedian(column.Key, considerSelection);
             ReplaceIndicesByValue<double>(column.Key, column.Value, median);
-          } else if (preprocessingData.IsType<DateTime>(column.Key)) {
+          } else if (preprocessingData.VariableHasType<DateTime>(column.Key)) {
             DateTime median = statisticsLogic.GetMedianDateTime(column.Key, considerSelection);
             ReplaceIndicesByValue<DateTime>(column.Key, column.Value, median);
@@ -84,5 +84,5 @@
 
         foreach (var column in cells) {
-          if (preprocessingData.IsType<double>(column.Key)) {
+          if (preprocessingData.VariableHasType<double>(column.Key)) {
             double max = statisticsLogic.GetMax<double>(column.Key, considerSelection);
             double min = statisticsLogic.GetMin<double>(column.Key, considerSelection);
@@ -92,5 +92,5 @@
               preprocessingData.SetCell<double>(column.Key, index, rand);
             }
-          } else if (preprocessingData.IsType<DateTime>(column.Key)) {
+          } else if (preprocessingData.VariableHasType<DateTime>(column.Key)) {
             DateTime min = statisticsLogic.GetMin<DateTime>(column.Key, considerSelection);
             DateTime max = statisticsLogic.GetMax<DateTime>(column.Key, considerSelection);
@@ -109,7 +109,7 @@
         foreach (var column in cells) {
           int countValues = 0;
-          if (preprocessingData.IsType<double>(column.Key)) {
+          if (preprocessingData.VariableHasType<double>(column.Key)) {
             countValues = preprocessingData.GetValues<double>(column.Key).Count();
-          } else if (preprocessingData.IsType<DateTime>(column.Key)) {
+          } else if (preprocessingData.VariableHasType<DateTime>(column.Key)) {
             countValues = preprocessingData.GetValues<DateTime>(column.Key).Count();
           }
@@ -170,5 +170,5 @@
       int valuesToInterpolate = nextIndex - prevIndex;
 
-      if (preprocessingData.IsType<double>(column.Key)) {
+      if (preprocessingData.VariableHasType<double>(column.Key)) {
         double prev = preprocessingData.GetCell<double>(column.Key, prevIndex);
         double next = preprocessingData.GetCell<double>(column.Key, nextIndex);
@@ -179,5 +179,5 @@
           preprocessingData.SetCell<double>(column.Key, i, interpolated);
         }
-      } else if (preprocessingData.IsType<DateTime>(column.Key)) {
+      } else if (preprocessingData.VariableHasType<DateTime>(column.Key)) {
         DateTime prev = preprocessingData.GetCell<DateTime>(column.Key, prevIndex);
         DateTime next = preprocessingData.GetCell<DateTime>(column.Key, nextIndex);
@@ -212,9 +212,9 @@
       preprocessingData.InTransaction(() => {
         foreach (var column in cells) {
-          if (preprocessingData.IsType<double>(column.Key)) {
+          if (preprocessingData.VariableHasType<double>(column.Key)) {
             ReplaceIndicesByValue<double>(column.Key, column.Value, statisticsLogic.GetMostCommonValue<double>(column.Key, considerSelection));
-          } else if (preprocessingData.IsType<string>(column.Key)) {
+          } else if (preprocessingData.VariableHasType<string>(column.Key)) {
             ReplaceIndicesByValue<string>(column.Key, column.Value, statisticsLogic.GetMostCommonValue<string>(column.Key, considerSelection));
-          } else if (preprocessingData.IsType<DateTime>(column.Key)) {
+          } else if (preprocessingData.VariableHasType<DateTime>(column.Key)) {
             ReplaceIndicesByValue<DateTime>(column.Key, column.Value, statisticsLogic.GetMostCommonValue<DateTime>(column.Key, considerSelection));
           } else {
@@ -265,9 +265,9 @@
       preprocessingData.InTransaction(() => {
         for (int i = 0; i < preprocessingData.Columns; ++i) {
-          if (preprocessingData.IsType<double>(i)) {
+          if (preprocessingData.VariableHasType<double>(i)) {
             reOrderToIndices<double>(i, indices);
-          } else if (preprocessingData.IsType<string>(i)) {
+          } else if (preprocessingData.VariableHasType<string>(i)) {
             reOrderToIndices<string>(i, indices);
-          } else if (preprocessingData.IsType<DateTime>(i)) {
+          } else if (preprocessingData.VariableHasType<DateTime>(i)) {
             reOrderToIndices<DateTime>(i, indices);
           }
@@ -279,9 +279,9 @@
       preprocessingData.InTransaction(() => {
         for (int i = 0; i < preprocessingData.Columns; ++i) {
-          if (preprocessingData.IsType<double>(i)) {
+          if (preprocessingData.VariableHasType<double>(i)) {
             ShuffleToIndices<double>(i, indices);
-          } else if (preprocessingData.IsType<string>(i)) {
+          } else if (preprocessingData.VariableHasType<string>(i)) {
             ShuffleToIndices<string>(i, indices);
-          } else if (preprocessingData.IsType<DateTime>(i)) {
+          } else if (preprocessingData.VariableHasType<DateTime>(i)) {
             ShuffleToIndices<DateTime>(i, indices);
           }
@@ -360,5 +360,5 @@
       List<int> columns = new List<int>();
       for (int i = 0; i < preprocessingData.Columns; ++i) {
-        if (preprocessingData.IsType<double>(i) || preprocessingData.IsType<DateTime>(i)) {
+        if (preprocessingData.VariableHasType<double>(i) || preprocessingData.VariableHasType<DateTime>(i)) {
           double columnVariance = statisticsLogic.GetVariance(i);
           if (columnVariance < variance) {
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingData.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingData.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingData.cs	(revision 11156)
@@ -52,5 +52,5 @@
       var doubleVariableNames = new List<string>();
       for (int i = 0; i < Columns; ++i) {
-        if (IsType<double>(i)) {
+        if (VariableHasType<double>(i)) {
           doubleVariableNames.Add(variableNames[i]);
         }
@@ -100,9 +100,9 @@
       variableValues = new List<IList>();
       foreach (var variableName in problemData.Dataset.VariableNames) {
-        if (dataset.IsType<double>(variableName)) {
+        if (dataset.VariableHasType<double>(variableName)) {
           variableValues.Insert(columnIndex, dataset.GetDoubleValues(variableName).ToList());
-        } else if (dataset.IsType<string>(variableName)) {
+        } else if (dataset.VariableHasType<string>(variableName)) {
           variableValues.Insert(columnIndex, dataset.GetStringValues(variableName).ToList());
-        } else if (dataset.IsType<DateTime>(variableName)) {
+        } else if (dataset.VariableHasType<DateTime>(variableName)) {
           variableValues.Insert(columnIndex, dataset.GetDateTimeValues(variableName).ToList());
         } else {
@@ -171,5 +171,5 @@
     public abstract int GetColumnIndex(string variableName);
 
-    public abstract bool IsType<T>(int columnIndex);
+    public abstract bool VariableHasType<T>(int columnIndex);
 
     [Obsolete("use the index based variant, is faster")]
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/SearchLogic.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/SearchLogic.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/SearchLogic.cs	(revision 11156)
@@ -85,9 +85,9 @@
 
     public bool IsMissingValue(int columnIndex, int rowIndex) {
-      if (preprocessingData.IsType<double>(columnIndex)) {
+      if (preprocessingData.VariableHasType<double>(columnIndex)) {
         return double.IsNaN(preprocessingData.GetCell<double>(columnIndex, rowIndex));
-      } else if (preprocessingData.IsType<string>(columnIndex)) {
+      } else if (preprocessingData.VariableHasType<string>(columnIndex)) {
         return string.IsNullOrEmpty(preprocessingData.GetCell<string>(columnIndex, rowIndex));
-      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+      } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
         return preprocessingData.GetCell<DateTime>(columnIndex, rowIndex).Equals(DateTime.MinValue);
       } else {
@@ -98,9 +98,9 @@
     public IList<int> GetMissingValueIndices(int columnIndex) {
       if (!MissingValueIndicies.ContainsKey(columnIndex)){        
-          if (preprocessingData.IsType<double>(columnIndex)) {
+          if (preprocessingData.VariableHasType<double>(columnIndex)) {
             MissingValueIndicies[columnIndex] = GetMissingValueIndices<double>(columnIndex);
-          } else if (preprocessingData.IsType<string>(columnIndex)) {
+          } else if (preprocessingData.VariableHasType<string>(columnIndex)) {
             MissingValueIndicies[columnIndex] = GetMissingValueIndices<string>(columnIndex);
-          } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+          } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
             MissingValueIndicies[columnIndex] = GetMissingValueIndices<DateTime>(columnIndex);
           } else {
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/StatisticsLogic.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/StatisticsLogic.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/StatisticsLogic.cs	(revision 11156)
@@ -49,5 +49,5 @@
 
       for (int i = 0; i < preprocessingData.Columns; ++i) {
-        if (preprocessingData.IsType<double>(i)) {
+        if (preprocessingData.VariableHasType<double>(i)) {
           ++count;
         }
@@ -82,5 +82,5 @@
     public double GetMedian(int columnIndex, bool considerSelection) {
       double median = double.NaN;
-      if (preprocessingData.IsType<double>(columnIndex)) {
+      if (preprocessingData.VariableHasType<double>(columnIndex)) {
         median = GetValuesWithoutNaN<double>(columnIndex, considerSelection).Median();
       }
@@ -90,5 +90,5 @@
     public double GetAverage(int columnIndex, bool considerSelection) {
       double avg = double.NaN;
-      if (preprocessingData.IsType<double>(columnIndex)) {
+      if (preprocessingData.VariableHasType<double>(columnIndex)) {
         avg = GetValuesWithoutNaN<double>(columnIndex, considerSelection).Average();
       }
@@ -98,5 +98,5 @@
     public DateTime GetMedianDateTime(int columnIndex, bool considerSelection) {
       DateTime median = new DateTime();
-      if (preprocessingData.IsType<DateTime>(columnIndex)) {
+      if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
         median = GetSecondsAsDateTime(GetDateTimeAsSeconds(columnIndex, considerSelection).Median());
       }
@@ -106,5 +106,5 @@
     public DateTime GetAverageDateTime(int columnIndex, bool considerSelection) {
       DateTime avg = new DateTime();
-      if (preprocessingData.IsType<DateTime>(columnIndex)) {
+      if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
         avg = GetSecondsAsDateTime(GetDateTimeAsSeconds(columnIndex, considerSelection).Average());
       }
@@ -127,7 +127,7 @@
     public double GetStandardDeviation(int columnIndex) {
       double stdDev = double.NaN;
-      if (preprocessingData.IsType<double>(columnIndex)) {
+      if (preprocessingData.VariableHasType<double>(columnIndex)) {
         stdDev = GetValuesWithoutNaN<double>(columnIndex).StandardDeviation();
-      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+      } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
         stdDev = GetDateTimeAsSeconds(columnIndex).StandardDeviation();
       }
@@ -137,7 +137,7 @@
     public double GetVariance(int columnIndex) {
       double variance = double.NaN;
-      if (preprocessingData.IsType<double>(columnIndex)) {
+      if (preprocessingData.VariableHasType<double>(columnIndex)) {
         variance = GetValuesWithoutNaN<double>(columnIndex).Variance();
-      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+      } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
         variance = GetDateTimeAsSeconds(columnIndex).Variance();
       }
@@ -163,14 +163,14 @@
     }
 
-    public bool IsType<T>(int columnIndex) {
-      return preprocessingData.IsType<T>(columnIndex);
+    public bool VariableHasType<T>(int columnIndex) {
+      return preprocessingData.VariableHasType<T>(columnIndex);
     }
 
     public string GetColumnTypeAsString(int columnIndex) {
-      if (preprocessingData.IsType<double>(columnIndex)) {
+      if (preprocessingData.VariableHasType<double>(columnIndex)) {
         return "double";
-      } else if (preprocessingData.IsType<string>(columnIndex)) {
+      } else if (preprocessingData.VariableHasType<string>(columnIndex)) {
         return "string";
-      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
+      } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
         return "DateTime";
       }
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/TransactionalPreprocessingData.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/TransactionalPreprocessingData.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Implementations/TransactionalPreprocessingData.cs	(revision 11156)
@@ -115,5 +115,5 @@
     }
 
-    public override bool IsType<T>(int columnIndex) {
+    public override bool VariableHasType<T>(int columnIndex) {
       return variableValues[columnIndex] is List<T>;
     }
@@ -138,5 +138,5 @@
     public override void SetValues<T>(int columnIndex, IList<T> values) {
       SaveSnapshot(DataPreprocessingChangedEventType.ChangeColumn, columnIndex, -1);
-      if (IsType<T>(columnIndex)) {
+      if (VariableHasType<T>(columnIndex)) {
         variableValues[columnIndex] = (IList)values;
       } else {
@@ -149,12 +149,12 @@
     public override bool SetValue(string value, int columnIndex, int rowIndex) {
       bool valid = false;
-      if (IsType<double>(columnIndex)) {
+      if (VariableHasType<double>(columnIndex)) {
         double val;
         valid = double.TryParse(value, out val);
         SetValueIfValid(columnIndex, rowIndex, valid, val);
-      } else if (IsType<string>(columnIndex)) {
+      } else if (VariableHasType<string>(columnIndex)) {
         valid = value != null;
         SetValueIfValid(columnIndex, rowIndex, valid, value);
-      } else if (IsType<DateTime>(columnIndex)) {
+      } else if (VariableHasType<DateTime>(columnIndex)) {
         DateTime date;
         valid = DateTime.TryParse(value, out date);
@@ -177,5 +177,5 @@
       bool valid = false;
       errorMessage = string.Empty;
-      if (IsType<double>(columnIndex)) {
+      if (VariableHasType<double>(columnIndex)) {
         double val;
         valid = double.TryParse(value, out val);
@@ -183,10 +183,10 @@
           errorMessage = "Invalid Value (Valid Value Format: \"" + FormatPatterns.GetDoubleFormatPattern() + "\")";
         }
-      } else if (IsType<string>(columnIndex)) {
+      } else if (VariableHasType<string>(columnIndex)) {
         valid = value != null;
         if (!valid) {
           errorMessage = "Invalid Value (string must not be null)";
         }
-      } else if (IsType<DateTime>(columnIndex)) {
+      } else if (VariableHasType<DateTime>(columnIndex)) {
         DateTime date;
         valid = DateTime.TryParse(value, out date);
@@ -207,5 +207,5 @@
 
     public override bool AreAllStringColumns(IEnumerable<int> columnIndices) {
-      return columnIndices.All(x => IsType<string>(x));
+      return columnIndices.All(x => VariableHasType<string>(x));
     }
 
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Interfaces/IPreprocessingData.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Interfaces/IPreprocessingData.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Interfaces/IPreprocessingData.cs	(revision 11156)
@@ -62,5 +62,5 @@
     int GetColumnIndex(string variableName);
 
-    bool IsType<T>(int columnIndex);
+    bool VariableHasType<T>(int columnIndex);
 
     int Columns { get; }
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Interfaces/IStatisticsLogic.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Interfaces/IStatisticsLogic.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/Interfaces/IStatisticsLogic.cs	(revision 11156)
@@ -46,5 +46,5 @@
     int GetDifferentValuesCount<T>(int columnIndex);
 
-    bool IsType<T>(int columnIndex);
+    bool VariableHasType<T>(int columnIndex);
     string GetColumnTypeAsString(int columnIndex);
     string GetVariableName(int columnIndex);
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/PreprocessingTransformator.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/PreprocessingTransformator.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/PreprocessingTransformator.cs	(revision 11156)
@@ -42,6 +42,6 @@
 
     public bool ApplyTransformations(IEnumerable<ITransformation> transformations, bool preserveColumns, out string errorMsg) {
-      bool success;
-
+      bool success = false;
+      errorMsg = string.Empty;
       preprocessingData.BeginTransaction(DataPreprocessingChangedEventType.Transformation);
 
@@ -64,4 +64,12 @@
           renamedColumns.Clear();
         }
+        // only accept changes if everything was successful
+        if (!success) {
+          preprocessingData.Undo();
+        }
+      }
+      catch (Exception e) {
+        preprocessingData.Undo();
+        if (string.IsNullOrEmpty(errorMsg)) errorMsg = e.Message;
       }
       finally {
@@ -103,5 +111,9 @@
     private IEnumerable<double> ApplyDoubleTransformation(Transformation<double> transformation, IList<double> data, out bool success, out string errorMsg) {
       success = transformation.Check(data, out errorMsg);
-      return transformation.Apply(data);
+      // don't apply when the check fails
+      if (success)
+        return transformation.Apply(data);
+      else
+        return data;
     }
 
Index: /trunk/sources/HeuristicLab.DataPreprocessing/3.4/ProblemDataCreator.cs
===================================================================
--- /trunk/sources/HeuristicLab.DataPreprocessing/3.4/ProblemDataCreator.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.DataPreprocessing/3.4/ProblemDataCreator.cs	(revision 11156)
@@ -91,5 +91,5 @@
       for (int i = 0; i < context.Data.Columns; ++i) {
         var variableName = context.Data.GetVariableName(i);
-        if (context.Data.IsType<double>(i)
+        if (context.Data.VariableHasType<double>(i)
           && variableName != targetVariable
           && IsNotConstantInputVariable(context.Data.GetValues<double>(i))) {
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionView.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionView.Designer.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionView.Designer.cs	(revision 11156)
@@ -97,5 +97,5 @@
       this.transformModelButton.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft;
       this.transformModelButton.Name = "transformModelButton";
-      this.transformModelButton.Size = new System.Drawing.Size(135, 23);
+      this.transformModelButton.Size = new System.Drawing.Size(135, 24);
       this.transformModelButton.TabIndex = 9;
       this.transformModelButton.Text = "Backtransform Model";
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionView.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionView.cs	(revision 11156)
@@ -75,8 +75,9 @@
       var transformations = Content.ProblemData.Transformations;
       var targetVar = Content.ProblemData.TargetVariable;
-      var newModel = transformator.Backtransform(Content.Model, transformations, targetVar);
-      Content.Model = (ISymbolicRegressionModel)newModel;
 
-      MessageBox.Show(this, "Backtransformation successful.");
+      var transformedModel = (ISymbolicRegressionModel)transformator.Backtransform(Content.Model, transformations, targetVar);
+      var transformedSolution = new SymbolicRegressionSolution(transformedModel, (IRegressionProblemData)Content.ProblemData.Clone());
+
+      MainFormManager.MainForm.ShowContent(transformedSolution);
     }
   }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 11155)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 11156)
@@ -126,4 +126,5 @@
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Interfaces\IModelBacktransformator.cs" />
     <Compile Include="Matching\SymbolicExpressionTreeCanonicalSorter.cs" />
     <Compile Include="Matching\SymbolicExpressionTreeEqualityComparer.cs" />
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IModelBacktransformator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IModelBacktransformator.cs	(revision 11156)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IModelBacktransformator.cs	(revision 11156)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  public interface IModelBacktransformator {
+    ISymbolicDataAnalysisModel Backtransform(ISymbolicDataAnalysisModel model, IEnumerable<ITransformation> transformations, string targetVariable);
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicExpressionTreeBacktransformator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicExpressionTreeBacktransformator.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicExpressionTreeBacktransformator.cs	(revision 11156)
@@ -33,5 +33,5 @@
     }
 
-    public IDataAnalysisModel Backtransform(IDataAnalysisModel model, IEnumerable<ITransformation> transformations, string targetVariable) {
+    public ISymbolicDataAnalysisModel Backtransform(ISymbolicDataAnalysisModel model, IEnumerable<ITransformation> transformations, string targetVariable) {
       var symbolicModel = (ISymbolicDataAnalysisModel)model.Clone();
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs	(revision 11156)
@@ -221,5 +221,5 @@
     }
 
-    public bool IsType<T>(string variableName) {
+    public bool VariableHasType<T>(string variableName) {
       return variableValues[variableName] is IList<T>;
     }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 11155)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 11156)
@@ -159,5 +159,4 @@
     <Compile Include="Interfaces\IDataAnalysisSolutionExporter.cs" />
     <Compile Include="Interfaces\IDependencyCalculator.cs" />
-    <Compile Include="Interfaces\IModelBacktransformator.cs" />
     <Compile Include="Interfaces\ITransformation.cs" />
     <Compile Include="Interfaces\ITransformationMapper.cs" />
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 11155)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 11156)
@@ -126,5 +126,5 @@
     }
 
-    protected DataAnalysisProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, IEnumerable<ITransformation> transformations) {
+    protected DataAnalysisProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, IEnumerable<ITransformation> transformations = null) {
       if (dataset == null) throw new ArgumentNullException("The dataset must not be null.");
       if (allowedInputVariables == null) throw new ArgumentNullException("The allowedInputVariables must not be null.");
@@ -132,6 +132,4 @@
       if (allowedInputVariables.Except(dataset.DoubleVariables).Any())
         throw new ArgumentException("All allowed input variables must be present in the dataset and of type double.");
-
-      if (transformations == null) throw new ArgumentNullException("The transformations must not be null.");
 
       var inputVariables = new CheckedItemList<StringValue>(dataset.DoubleVariables.Select(x => new StringValue(x)));
@@ -144,5 +142,5 @@
       int testPartitionEnd = dataset.Rows;
 
-      var transformationsList = new ItemList<ITransformation>(transformations);
+      var transformationsList = new ItemList<ITransformation>(transformations ?? Enumerable.Empty<ITransformation>());
 
       Parameters.Add(new FixedValueParameter<Dataset>(DatasetParameterName, "", dataset));
Index: unk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IModelBacktransformator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IModelBacktransformator.cs	(revision 11155)
+++ 	(revision )
@@ -1,29 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System.Collections.Generic;
-
-
-namespace HeuristicLab.Problems.DataAnalysis {
-  public interface IModelBacktransformator {
-    IDataAnalysisModel Backtransform(IDataAnalysisModel model, IEnumerable<ITransformation> transformations, string targetVariable);
-  }
-}
