Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/CopyColumnTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/CopyColumnTransformation.cs	(revision 12637)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/CopyColumnTransformation.cs	(revision 12667)
@@ -29,4 +29,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
   [Item("CopyColumnTransformation", "Represents a transformation which represents a copied Column.")]
   public class CopyColumnTransformation : Transformation {
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ExponentialTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ExponentialTransformation.cs	(revision 12637)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ExponentialTransformation.cs	(revision 12667)
@@ -1,4 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -8,4 +9,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
   [Item("Exponential Transformation", "f(x) = b ^ x | Represents a exponential transformation.")]
   public class ExponentialTransformation : Transformation<double> {
@@ -44,7 +46,5 @@
 
     public override IEnumerable<double> Apply(IEnumerable<double> data) {
-      foreach (double d in data) {
-        yield return Math.Pow(Base, d);
-      }
+      return data.Select(d => Math.Pow(Base, d));
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs	(revision 12637)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs	(revision 12667)
@@ -31,4 +31,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
   [Item("Linear Transformation", "f(x) = k * x + d | Represents a linear transformation with multiplication and addition.")]
   public class LinearTransformation : Transformation<double> {
@@ -80,10 +81,12 @@
 
     public override IEnumerable<double> Apply(IEnumerable<double> data) {
-      return data.Select(e => e * Multiplier + Addend);
+      var m = Multiplier;
+      var a = Addend;
+      return data.Select(e => e * m + a);
     }
 
     public override bool Check(IEnumerable<double> data, out string errorMsg) {
       errorMsg = null;
-      if (Multiplier == 0.0) {
+      if (Multiplier.IsAlmost(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;
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LogarithmicTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LogarithmicTransformation.cs	(revision 12637)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LogarithmicTransformation.cs	(revision 12667)
@@ -9,4 +9,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
   [Item("Logarithmic Transformation", "f(x) = log(x, b) | Represents a logarithmic transformation.")]
   public class LogarithmicTransformation : Transformation<double> {
@@ -43,10 +44,6 @@
 
     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;
-      }
+      var b = Base;
+      return data.Select(d => d > 0.0 ? Math.Log(d, b) : d);
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/PowerTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/PowerTransformation.cs	(revision 12637)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/PowerTransformation.cs	(revision 12667)
@@ -1,4 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -8,4 +9,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
   [Item("Power Transformation", "f(x) = x ^ exp | Represents a power transformation.")]
   public class PowerTransformation : Transformation<double> {
@@ -42,7 +44,5 @@
 
     public override IEnumerable<double> Apply(IEnumerable<double> data) {
-      foreach (double i in data) {
-        yield return Math.Pow(i, Exponent);
-      }
+      return data.Select(i => Math.Pow(i, Exponent));
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ReciprocalTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ReciprocalTransformation.cs	(revision 12637)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ReciprocalTransformation.cs	(revision 12667)
@@ -7,4 +7,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
   [Item("Reciprocal Transformation", "f(x) = 1 / x | Represents a reciprocal transformation.")]
   public class ReciprocalTransformation : Transformation<double> {
@@ -16,5 +17,4 @@
     #endregion
 
-    //TODO: is a special case of Linear
     [StorableConstructor]
     protected ReciprocalTransformation(bool deserializing) : base(deserializing) { }
@@ -31,10 +31,5 @@
 
     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;
-      }
+      return data.Select(d => d > 0 ? 1.0 / d : d);
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftStandardDistributionTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftStandardDistributionTransformation.cs	(revision 12637)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftStandardDistributionTransformation.cs	(revision 12667)
@@ -8,4 +8,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
   [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> {
@@ -69,20 +70,16 @@
     }
 
-    // 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;
+      if (OriginalStandardDeviation.IsAlmost(0.0)) {
+        return data;
       }
-
-      foreach (var e in data) {
-        double unitNormalDistributedValue = (e - OriginalMean) / OriginalStandardDeviation;
-        yield return unitNormalDistributedValue * StandardDeviation + Mean;
-      }
+      var old_m = OriginalMean;
+      var old_s = OriginalStandardDeviation;
+      var m = Mean;
+      var s = StandardDeviation;
+      return data
+        .Select(d => (d - old_m) / old_s) // standardized
+        .Select(d => d * s + m);
     }
 
@@ -90,5 +87,5 @@
       ConfigureParameters(data);
       errorMsg = "";
-      if (OriginalStandardDeviation == 0.0) {
+      if (OriginalStandardDeviation.IsAlmost(0.0)) {
         errorMsg = "Standard deviaton for the original data is 0.0, Transformation cannot be applied onto these values.";
         return false;
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftToRangeTransformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftToRangeTransformation.cs	(revision 12637)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ShiftToRangeTransformation.cs	(revision 12667)
@@ -8,4 +8,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
   [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 {
Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/Transformation.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/Transformation.cs	(revision 12637)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/Transformation.cs	(revision 12667)
@@ -31,5 +31,4 @@
 
   [Item("Transformation", "Represents the base class for a transformation.")]
-  [StorableClass]
   public abstract class Transformation : ParameterizedNamedItem, ITransformation {
     protected const string ColumnParameterName = "Column";
