Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs	(revision 11158)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs	(revision 11159)
@@ -300,6 +300,6 @@
     }
 
-    public ClassificationProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable)
-      : base(dataset, allowedInputVariables) {
+    public ClassificationProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
+      : base(dataset, allowedInputVariables, transformations ?? Enumerable.Empty<ITransformation>()) {
       var validTargetVariableValues = CheckVariablesForPossibleTargetVariables(dataset).Select(x => new StringValue(x).AsReadOnly()).ToList();
       var target = validTargetVariableValues.Where(x => x.Value == targetVariable).DefaultIfEmpty(validTargetVariableValues.First()).First();
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringProblemData.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringProblemData.cs	(revision 11158)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringProblemData.cs	(revision 11159)
@@ -21,4 +21,5 @@
 
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -86,6 +87,6 @@
     }
 
-    public ClusteringProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables)
-      : base(dataset, allowedInputVariables) {
+    public ClusteringProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, IEnumerable<ITransformation> transformations = null)
+      : base(dataset, allowedInputVariables, transformations ?? Enumerable.Empty<ITransformation>()) {
     }
   }
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 11158)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 11159)
@@ -38,4 +38,5 @@
     protected const string TrainingPartitionParameterName = "TrainingPartition";
     protected const string TestPartitionParameterName = "TestPartition";
+    protected const string TransformationsParameterName = "Transformations";
 
     #region parameter properites
@@ -51,4 +52,7 @@
     public IFixedValueParameter<IntRange> TestPartitionParameter {
       get { return (IFixedValueParameter<IntRange>)Parameters[TestPartitionParameterName]; }
+    }
+    public IFixedValueParameter<ReadOnlyItemList<ITransformation>> TransformationsParameter {
+      get { return (IFixedValueParameter<ReadOnlyItemList<ITransformation>>)Parameters[TransformationsParameterName]; }
     }
     #endregion
@@ -89,4 +93,8 @@
     }
 
+    public IEnumerable<ITransformation> Transformations {
+      get { return TransformationsParameter.Value; }
+    }
+
     public virtual bool IsTrainingSample(int index) {
       return index >= 0 && index < Dataset.Rows &&
@@ -111,8 +119,12 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(TransformationsParameterName)) {
+        Parameters.Add(new FixedValueParameter<ReadOnlyItemList<ITransformation>>(TransformationsParameterName, "", new ItemList<ITransformation>().AsReadOnly()));
+        TransformationsParameter.Hidden = true;
+      }
       RegisterEventHandlers();
     }
 
-    protected DataAnalysisProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables) {
+    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.");
@@ -130,8 +142,13 @@
       int testPartitionEnd = dataset.Rows;
 
+      var transformationsList = new ItemList<ITransformation>(transformations ?? Enumerable.Empty<ITransformation>());
+
       Parameters.Add(new FixedValueParameter<Dataset>(DatasetParameterName, "", dataset));
       Parameters.Add(new FixedValueParameter<ReadOnlyCheckedItemList<StringValue>>(InputVariablesParameterName, "", inputVariables.AsReadOnly()));
       Parameters.Add(new FixedValueParameter<IntRange>(TrainingPartitionParameterName, "", new IntRange(trainingPartitionStart, trainingPartitionEnd)));
       Parameters.Add(new FixedValueParameter<IntRange>(TestPartitionParameterName, "", new IntRange(testPartitionStart, testPartitionEnd)));
+      Parameters.Add(new FixedValueParameter<ReadOnlyItemList<ITransformation>>(TransformationsParameterName, "", transformationsList.AsReadOnly()));
+
+      TransformationsParameter.Hidden = true;
 
       ((ValueParameter<Dataset>)DatasetParameter).ReactOnValueToStringChangedAndValueItemImageChanged = false;
@@ -144,4 +161,5 @@
       TrainingPartition.ValueChanged += new EventHandler(Parameter_ValueChanged);
       TestPartition.ValueChanged += new EventHandler(Parameter_ValueChanged);
+      TransformationsParameter.ValueChanged += new EventHandler(Parameter_ValueChanged);
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 11158)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 11159)
@@ -137,6 +137,6 @@
     }
 
-    public RegressionProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable)
-      : base(dataset, allowedInputVariables) {
+    public RegressionProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
+      : base(dataset, allowedInputVariables, transformations ?? Enumerable.Empty<ITransformation>()) {
       var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
       Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.Where(x => x.Value == targetVariable).First()));
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisProblemData.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisProblemData.cs	(revision 11158)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisProblemData.cs	(revision 11159)
@@ -1582,6 +1582,6 @@
       TrainingPartition.Start = 50;
     }
-    public TimeSeriesPrognosisProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable)
-      : base(dataset, allowedInputVariables, targetVariable) {
+    public TimeSeriesPrognosisProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
+      : base(dataset, allowedInputVariables, targetVariable, transformations ?? Enumerable.Empty<ITransformation>()) {
       Parameters.Add(new FixedValueParameter<IntValue>(TrainingHorizonParameterName, "Specifies the horizon (how far the prognosis reaches in the future) for each training sample.", new IntValue(1)));
       Parameters.Add(new FixedValueParameter<IntValue>(TestHorizonParameterName, "Specifies the horizon (how far the prognosis reaches in the future) for each test sample.", new IntValue(1)));
@@ -1643,7 +1643,7 @@
 
       var trainingDataStart = TrainingIndices.First();
-      
+
       base.AdjustProblemDataProperties(problemData);
-      
+
       TestPartition.Start = trainingDataStart;
 
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/CopyColumnTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/CopyColumnTransformation.cs	(revision 11159)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/CopyColumnTransformation.cs	(revision 11159)
@@ -0,0 +1,64 @@
+﻿#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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [Item("CopyColumnTransformation", "Represents a transformation which represents a copied Column.")]
+  public class CopyColumnTransformation : Transformation {
+    protected const string CopiedColumnNameParameterName = "CopiedColumnName";
+
+    #region Parameters
+    public IValueParameter<StringValue> CopiedColumnNameParameter {
+      get { return (IValueParameter<StringValue>)Parameters[CopiedColumnNameParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public override string ShortName {
+      get { return "Cpy"; }
+    }
+    public string CopiedColumnName {
+      get { return CopiedColumnNameParameter.Value.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected CopyColumnTransformation(bool deserializing) : base(deserializing) { }
+    protected CopyColumnTransformation(CopyColumnTransformation original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public CopyColumnTransformation()
+      : base(Enumerable.Empty<string>()) {
+      Parameters.Add(new ValueParameter<StringValue>(CopiedColumnNameParameterName, "Name for the copied column", new StringValue()));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CopyColumnTransformation(this, cloner);
+    }
+  }
+}
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ExponentialTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ExponentialTransformation.cs	(revision 11159)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ExponentialTransformation.cs	(revision 11159)
@@ -0,0 +1,56 @@
+﻿using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [Item("Exponential Transformation", "f(x) = b ^ x | Represents a exponential transformation.")]
+  public class ExponentialTransformation : Transformation<double> {
+    protected const string BaseParameterName = "Base";
+
+    #region Parameters
+    public IValueParameter<DoubleValue> BaseParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[BaseParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public override string ShortName {
+      get { return "Exp"; }
+    }
+    public double Base {
+      get { return BaseParameter.Value.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected ExponentialTransformation(bool deserializing) : base(deserializing) { }
+
+    protected ExponentialTransformation(ExponentialTransformation original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public ExponentialTransformation(IEnumerable<string> allowedColumns)
+      : base(allowedColumns) {
+      Parameters.Add(new ValueParameter<DoubleValue>(BaseParameterName, "b | Base of exp-function", new DoubleValue(Math.E)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExponentialTransformation(this, cloner);
+    }
+
+    public override IEnumerable<double> Apply(IEnumerable<double> data) {
+      foreach (double d in data) {
+        yield return Math.Pow(Base, d);
+      }
+    }
+
+    public override bool Check(IEnumerable<double> data, out string errorMsg) {
+      errorMsg = "";
+      return true;
+    }
+  }
+}
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs	(revision 11159)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs	(revision 11159)
@@ -0,0 +1,94 @@
+﻿#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;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [Item("Linear Transformation", "f(x) = k * x + d | Represents a linear transformation with multiplication and addition.")]
+  public class LinearTransformation : Transformation<double> {
+    protected const string MultiplierParameterName = "Multiplier";
+    protected const string AddendParameterName = "Addend";
+
+    #region Parameters
+    public IValueParameter<DoubleValue> MultiplierParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[MultiplierParameterName]; }
+    }
+    public IValueParameter<DoubleValue> AddendParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[AddendParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public override string ShortName {
+      get { return "Lin"; }
+    }
+    public double Multiplier {
+      get { return MultiplierParameter.Value.Value; }
+      protected set {
+        MultiplierParameter.Value.Value = value;
+      }
+    }
+
+    public double Addend {
+      get { return AddendParameter.Value.Value; }
+      protected set {
+        AddendParameter.Value.Value = value;
+      }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected LinearTransformation(bool deserializing) : base(deserializing) { }
+    protected LinearTransformation(LinearTransformation original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public LinearTransformation(IEnumerable<string> allowedColumns)
+      : base(allowedColumns) {
+      Parameters.Add(new ValueParameter<DoubleValue>(MultiplierParameterName, "k | Multiplier for linear transformation", new DoubleValue(1.0)));
+      Parameters.Add(new ValueParameter<DoubleValue>(AddendParameterName, "d | Addend for linear transformation", new DoubleValue(0.0)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LinearTransformation(this, cloner);
+    }
+
+    public override IEnumerable<double> Apply(IEnumerable<double> data) {
+      return data.Select(e => e * Multiplier + Addend);
+    }
+
+    public override bool Check(IEnumerable<double> data, out string errorMsg) {
+      errorMsg = null;
+      if (Multiplier == 0.0) {
+        errorMsg = String.Format("Multiplicand is 0, all {0} entries will be set to {1}. Inverse apply will not be possible (division by 0).", data.Count(), Addend);
+        return false;
+      }
+      return true;
+    }
+  }
+}
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LogarithmicTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LogarithmicTransformation.cs	(revision 11159)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LogarithmicTransformation.cs	(revision 11159)
@@ -0,0 +1,64 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [Item("Logarithmic Transformation", "f(x) = log(x, b) | Represents a logarithmic transformation.")]
+  public class LogarithmicTransformation : Transformation<double> {
+    protected const string BaseParameterName = "Base";
+
+    #region Parameters
+    public IValueParameter<DoubleValue> BaseParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[BaseParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public override string ShortName {
+      get { return "Log"; }
+    }
+    public double Base {
+      get { return BaseParameter.Value.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected LogarithmicTransformation(bool deserializing) : base(deserializing) { }
+    protected LogarithmicTransformation(LogarithmicTransformation original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public LogarithmicTransformation(IEnumerable<string> allowedColumns)
+      : base(allowedColumns) {
+      Parameters.Add(new ValueParameter<DoubleValue>(BaseParameterName, "b | Base of log-function", new DoubleValue(Math.E)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LogarithmicTransformation(this, cloner);
+    }
+
+    public override IEnumerable<double> Apply(IEnumerable<double> data) {
+      foreach (double i in data) {
+        if (i > 0.0)
+          yield return Math.Log(i, Base);
+        else
+          yield return i;
+      }
+    }
+
+    public override bool Check(IEnumerable<double> data, out string errorMsg) {
+      errorMsg = null;
+      int errorCounter = data.Count(i => i <= 0.0);
+      if (errorCounter > 0) {
+        errorMsg = String.Format("{0} values are zero or below zero. Logarithm can not be applied onto these values", errorCounter);
+        return false;
+      }
+      return true;
+    }
+
+  }
+}
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/PowerTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/PowerTransformation.cs	(revision 11159)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/PowerTransformation.cs	(revision 11159)
@@ -0,0 +1,55 @@
+﻿using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [Item("Power Transformation", "f(x) = x ^ exp | Represents a power transformation.")]
+  public class PowerTransformation : Transformation<double> {
+    protected const string ExponentParameterName = "Exponent";
+
+    #region Parameters
+    public IValueParameter<DoubleValue> ExponentParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[ExponentParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public override string ShortName {
+      get { return "Pow"; }
+    }
+    public double Exponent {
+      get { return ExponentParameter.Value.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected PowerTransformation(bool deserializing) : base(deserializing) { }
+    protected PowerTransformation(PowerTransformation original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PowerTransformation(IEnumerable<string> allowedColumns)
+      : base(allowedColumns) {
+      Parameters.Add(new ValueParameter<DoubleValue>(ExponentParameterName, "exp | Exponent for Exponentation", new DoubleValue(2.0)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PowerTransformation(this, cloner);
+    }
+
+    public override IEnumerable<double> Apply(IEnumerable<double> data) {
+      foreach (double i in data) {
+        yield return Math.Pow(i, Exponent);
+      }
+    }
+
+    public override bool Check(IEnumerable<double> data, out string errorMsg) {
+      errorMsg = "";
+      return true;
+    }
+
+  }
+}
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ReciprocalTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ReciprocalTransformation.cs	(revision 11159)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ReciprocalTransformation.cs	(revision 11159)
@@ -0,0 +1,51 @@
+﻿
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Problems.DataAnalysis {
+  [Item("Reciprocal Transformation", "f(x) = 1 / x | Represents a reciprocal transformation.")]
+  public class ReciprocalTransformation : Transformation<double> {
+
+    #region properties
+    public override string ShortName {
+      get { return "Inv"; }
+    }
+    #endregion
+
+    //TODO: is a special case of Linear
+    [StorableConstructor]
+    protected ReciprocalTransformation(bool deserializing) : base(deserializing) { }
+    protected ReciprocalTransformation(ReciprocalTransformation original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public ReciprocalTransformation(IEnumerable<string> allowedColumns)
+      : base(allowedColumns) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReciprocalTransformation(this, cloner);
+    }
+
+    public override IEnumerable<double> Apply(IEnumerable<double> data) {
+      foreach (double i in data) {
+        if (i > 0.0)
+          yield return 1.0 / i;
+        else
+          yield return i;
+      }
+    }
+
+    public override bool Check(IEnumerable<double> data, out string errorMsg) {
+      errorMsg = null;
+      int errorCounter = data.Count(i => i <= 0.0);
+      if (errorCounter > 0) {
+        errorMsg = String.Format("{0} values are zero or below zero. 1/x can not be applied onto these values", errorCounter);
+        return false;
+      }
+      return true;
+    }
+  }
+}
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftStandardDistributionTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftStandardDistributionTransformation.cs	(revision 11159)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftStandardDistributionTransformation.cs	(revision 11159)
@@ -0,0 +1,104 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [Item("Shift Standard Distribution Transformation", "f(x) = ((x - m_org) / s_org ) * s_tar + m_tar | Represents Transformation to unit standard deviation and additional linear transformation to a target Mean and Standard deviation")]
+  public class ShiftStandardDistributionTransformation : Transformation<double> {
+    protected const string OriginalMeanParameterName = "Original Mean";
+    protected const string OriginalStandardDeviationParameterName = "Original Standard Deviation";
+    protected const string MeanParameterName = "Mean";
+    protected const string StandardDeviationParameterName = "Standard Deviation";
+
+    #region Parameters
+    public IValueParameter<DoubleValue> OriginalMeanParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[OriginalMeanParameterName]; }
+    }
+    public IValueParameter<DoubleValue> OriginalStandardDeviationParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[OriginalStandardDeviationParameterName]; }
+    }
+    public IValueParameter<DoubleValue> MeanParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[MeanParameterName]; }
+    }
+    public IValueParameter<DoubleValue> StandardDeviationParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[StandardDeviationParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public override string ShortName {
+      get { return "Std"; }
+    }
+    public double OriginalMean {
+      get { return OriginalMeanParameter.Value.Value; }
+      set { OriginalMeanParameter.Value.Value = value; }
+    }
+    public double OriginalStandardDeviation {
+      get { return OriginalStandardDeviationParameter.Value.Value; }
+      set { OriginalStandardDeviationParameter.Value.Value = value; }
+    }
+    public double Mean {
+      get { return MeanParameter.Value.Value; }
+    }
+    public double StandardDeviation {
+      get { return StandardDeviationParameter.Value.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected ShiftStandardDistributionTransformation(bool deserializing) : base(deserializing) { }
+    protected ShiftStandardDistributionTransformation(ShiftStandardDistributionTransformation original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public ShiftStandardDistributionTransformation(IEnumerable<string> allowedColumns)
+      : base(allowedColumns) {
+      Parameters.Add(new ValueParameter<DoubleValue>(OriginalMeanParameterName, "m_org | Mean value of the original data's deviation.", new DoubleValue()));
+      Parameters.Add(new ValueParameter<DoubleValue>(OriginalStandardDeviationParameterName, "s_org | Standard deviation of the original data.", new DoubleValue()));
+      OriginalMeanParameter.Hidden = true;
+      OriginalStandardDeviationParameter.Hidden = true;
+      Parameters.Add(new ValueParameter<DoubleValue>(MeanParameterName, "m_tar | Mean value for the target deviation.", new DoubleValue(0.0)));
+      Parameters.Add(new ValueParameter<DoubleValue>(StandardDeviationParameterName, "s_tar | Standard deviation for the target data.", new DoubleValue(1.0)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ShiftStandardDistributionTransformation(this, cloner);
+    }
+
+    // http://en.wikipedia.org/wiki/Standard_deviation
+    // http://www.statistics4u.info/fundstat_germ/ee_ztransform.html
+    // https://www.uni-due.de/~bm0061/vorl12.pdf p5
+    public override IEnumerable<double> Apply(IEnumerable<double> data) {
+      ConfigureParameters(data);
+      if (OriginalStandardDeviation == 0.0) {
+        foreach (var e in data) {
+          yield return e;
+        }
+        yield break;
+      }
+
+      foreach (var e in data) {
+        double unitNormalDistributedValue = (e - OriginalMean) / OriginalStandardDeviation;
+        yield return unitNormalDistributedValue * StandardDeviation + Mean;
+      }
+    }
+
+    public override bool Check(IEnumerable<double> data, out string errorMsg) {
+      ConfigureParameters(data);
+      errorMsg = "";
+      if (OriginalStandardDeviation == 0.0) {
+        errorMsg = "Standard deviaton for the original data is 0.0, Transformation cannot be applied onto these values.";
+        return false;
+      }
+      return true;
+    }
+
+    protected void ConfigureParameters(IEnumerable<double> data) {
+      OriginalStandardDeviation = data.StandardDeviation();
+      OriginalMean = data.Average();
+    }
+  }
+}
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftToRangeTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftToRangeTransformation.cs	(revision 11159)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftToRangeTransformation.cs	(revision 11159)
@@ -0,0 +1,66 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [Item("Shift to Range Transformation", "f(x) = k * x + d, start <= f(x) <= end | Represents a linear Transformation using Parameters defining a target range")]
+  public class ShiftToRangeTransformation : LinearTransformation {
+    protected const string RangeParameterName = "Range";
+
+    #region Parameters
+    public IValueParameter<DoubleRange> RangeParameter {
+      get { return (IValueParameter<DoubleRange>)Parameters[RangeParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public override string ShortName {
+      get { return "Sft"; }
+    }
+    public DoubleRange Range {
+      get { return RangeParameter.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected ShiftToRangeTransformation(bool deserializing) : base(deserializing) { }
+    protected ShiftToRangeTransformation(ShiftToRangeTransformation original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public ShiftToRangeTransformation(IEnumerable<string> allowedColumns)
+      : base(allowedColumns) {
+      MultiplierParameter.Hidden = true;
+      AddendParameter.Hidden = true;
+      Parameters.Add(new ValueParameter<DoubleRange>(RangeParameterName, "start, end | Range for the target window of the linear transformation", new DoubleRange(0.0, 1.0)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ShiftToRangeTransformation(this, cloner);
+    }
+
+    public override IEnumerable<double> Apply(IEnumerable<double> data) {
+      ConfigureParameters(data);
+      return base.Apply(data);
+    }
+
+    public override bool Check(IEnumerable<double> data, out string errorMsg) {
+      ConfigureParameters(data);
+      return base.Check(data, out errorMsg);
+    }
+
+    protected void ConfigureParameters(IEnumerable<double> data) {
+      double originalRangeStart = data.Min();
+      double originalRangeEnd = data.Max();
+
+      double originalRangeWidth = originalRangeEnd - originalRangeStart;
+      double targetRangeWidth = Range.End - Range.Start;
+
+      Multiplier = targetRangeWidth / originalRangeWidth;
+      Addend = Range.Start - originalRangeStart * Multiplier;
+    }
+  }
+}
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/Transformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/Transformation.cs	(revision 11159)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/Transformation.cs	(revision 11159)
@@ -0,0 +1,72 @@
+﻿#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;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+
+  [Item("Transformation", "Represents the base class for a transformation.")]
+  [StorableClass]
+  public abstract class Transformation : ParameterizedNamedItem, ITransformation {
+    protected const string ColumnParameterName = "Column";
+    #region parameter properties
+    public IConstrainedValueParameter<StringValue> ColumnParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[ColumnParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public abstract string ShortName { get; }
+
+    public string Column {
+      get { return ColumnParameter.Value.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected Transformation(bool deserializing) : base(deserializing) { }
+    protected Transformation(Transformation original, Cloner cloner) : base(original, cloner) { }
+    protected Transformation(IEnumerable<string> allowedColumns) {
+      var allowed = new ItemSet<StringValue>(allowedColumns.Select(e => new StringValue(e)));
+      Parameters.Add(new ConstrainedValueParameter<StringValue>(ColumnParameterName, "Column used for the Transformation", allowed));
+    }
+  }
+
+  [Item("Transformation", "Represents the base class for a transformation.")]
+  [StorableClass]
+  public abstract class Transformation<T> : Transformation, ITransformation<T> {
+
+    [StorableConstructor]
+    protected Transformation(bool deserializing) : base(deserializing) { }
+    protected Transformation(Transformation<T> original, Cloner cloner) : base(original, cloner) { }
+    protected Transformation(IEnumerable<string> allowedColumns) : base(allowedColumns) { }
+
+    public abstract IEnumerable<T> Apply(IEnumerable<T> data);
+
+    public abstract bool Check(IEnumerable<T> data, out string errorMsg);
+  }
+}
