Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Addition.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Addition.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Addition.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Addition", "Symbol that represents the + operator.")]
   public sealed class Addition : Symbol {
+    [StorableConstructor]
+    private Addition(bool deserializing) : base(deserializing) { }
+    private Addition(Addition original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Addition(this, cloner);
+    }
     public Addition() : base("Addition", "Symbol that represents the + operator.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/And.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/And.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/And.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("And", "Symbol that represents the boolean AND operator.")]
   public sealed class And : Symbol {
+    [StorableConstructor]
+    private And(bool deserializing) : base(deserializing) { }
+    private And(And original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new And(this, cloner);
+    }
     public And() : base("And", "Symbol that represents the boolean AND operator.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Average.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Average.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Average.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Average", "Symbol that represents the average (arithmetic mean) function.")]
   public sealed class Average : Symbol {
+    [StorableConstructor]
+    private Average(bool deserializing) : base(deserializing) { }
+    private Average(Average original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Average(this, cloner);
+    }
     public Average() : base("Average", "Symbol that represents the average (arithmetic mean) function.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Constant.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Constant.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Constant.cs	(revision 5275)
@@ -54,10 +54,10 @@
     }
     [Storable]
-    private double manipulatorNu;
-    public double ManipulatorNu {
-      get { return manipulatorNu; }
+    private double manipulatorMu;
+    public double ManipulatorMu {
+      get { return manipulatorMu; }
       set {
-        if (value != manipulatorNu) {
-          manipulatorNu = value;
+        if (value != manipulatorMu) {
+          manipulatorMu = value;
           OnChanged(EventArgs.Empty);
         }
@@ -77,7 +77,16 @@
     }
     #endregion
+    [StorableConstructor]
+    private Constant(bool deserializing) : base(deserializing) { }
+    private Constant(Constant original, Cloner cloner)
+      : base(original, cloner) {
+      minValue = original.minValue;
+      maxValue = original.maxValue;
+      manipulatorMu = original.manipulatorMu;
+      manipulatorSigma = original.manipulatorSigma;
+    }
     public Constant()
       : base("Constant", "Represents a constant value.") {
-      manipulatorNu = 0.0;
+      manipulatorMu = 0.0;
       manipulatorSigma = 1.0;
       minValue = -20.0;
@@ -90,10 +99,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      Constant clone = (Constant)base.Clone(cloner);
-      clone.minValue = minValue;
-      clone.maxValue = maxValue;
-      clone.manipulatorNu = manipulatorNu;
-      clone.manipulatorSigma = manipulatorSigma;
-      return clone;
+      return new Constant(this, cloner);
     }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/ConstantTreeNode.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/ConstantTreeNode.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/ConstantTreeNode.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
@@ -38,12 +39,13 @@
     }
 
-    private ConstantTreeNode() : base() { }
+    [StorableConstructor]
+    private ConstantTreeNode(bool deserializing) : base(deserializing) { }
 
-    // copy constructor
-    private ConstantTreeNode(ConstantTreeNode original)
-      : base(original) {
+    private ConstantTreeNode(ConstantTreeNode original, Cloner cloner)
+      : base(original, cloner) {
       constantValue = original.constantValue;
     }
 
+    private ConstantTreeNode() : base() { }
     public ConstantTreeNode(Constant constantSymbol) : base(constantSymbol) { }
 
@@ -61,10 +63,10 @@
     public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
       base.ShakeLocalParameters(random, shakingFactor);
-      double x = NormalDistributedRandom.NextDouble(random, Symbol.ManipulatorNu, Symbol.ManipulatorSigma);
+      double x = NormalDistributedRandom.NextDouble(random, Symbol.ManipulatorMu, Symbol.ManipulatorSigma);
       Value = Value + x * shakingFactor;
     }
 
-    public override object Clone() {
-      return new ConstantTreeNode(this);
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConstantTreeNode(this, cloner);
     }
 
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Cosine.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Cosine.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Cosine.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Cosine", "Symbol that represents the cosine function.")]
   public sealed class Cosine : Symbol {
+    [StorableConstructor]
+    private Cosine(bool deserializing) : base(deserializing) { }
+    private Cosine(Cosine original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Cosine(this, cloner);
+    }
     public Cosine() : base("Cosine", "Symbol that represents the cosine function.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/DifferentialVariable.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/DifferentialVariable.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/DifferentialVariable.cs	(revision 5275)
@@ -28,4 +28,9 @@
   [Item("DifferentialVariable", "Represents the differential of a variable value.")]
   public sealed class DifferentialVariable : Variable {
+    [StorableConstructor]
+    private DifferentialVariable(bool deserializing) : base(deserializing) { }
+    private DifferentialVariable(DifferentialVariable original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public DifferentialVariable()
       : base("DifferentialVariable", "Represents the differential of a variable value.") {
@@ -35,8 +40,6 @@
       return new DifferentialVariableTreeNode(this);
     }
-
     public override IDeepCloneable Clone(Cloner cloner) {
-      DifferentialVariable clone = (DifferentialVariable)base.Clone(cloner);
-      return clone;
+      return new DifferentialVariable(this, cloner);
     }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/DifferentialVariableTreeNode.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/DifferentialVariableTreeNode.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/DifferentialVariableTreeNode.cs	(revision 5275)
@@ -23,4 +23,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols {
   [StorableClass]
@@ -30,18 +31,17 @@
     }
 
+    [StorableConstructor]
+    protected DifferentialVariableTreeNode(bool deserializing) : base(deserializing) { }
+    protected DifferentialVariableTreeNode(DifferentialVariableTreeNode original, Cloner cloner)
+      : base(original, cloner) {
+    }
     private DifferentialVariableTreeNode() { }
-
-    // copy constructor
-    private DifferentialVariableTreeNode(DifferentialVariableTreeNode original)
-      : base(original) {
-    }
 
     public DifferentialVariableTreeNode(DifferentialVariable differentialSymbol) : base(differentialSymbol) { }
 
 
-    public override object Clone() {
-      return new DifferentialVariableTreeNode(this);
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DifferentialVariableTreeNode(this, cloner);
     }
-
   }
 }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Division.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Division.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Division.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Division", "Symbol that represents the / operator.")]
   public sealed class Division : Symbol {
+    [StorableConstructor]
+    private Division(bool deserializing) : base(deserializing) { }
+    private Division(Division original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Division(this, cloner);
+    }
     public Division() : base("Division", "Symbol that represents the / operator.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Exponential.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Exponential.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Exponential.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Exponential", "Symbol that represents the exponential function.")]
   public sealed class Exponential : Symbol {
+    [StorableConstructor]
+    private Exponential(bool deserializing) : base(deserializing) { }
+    private Exponential(Exponential original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Exponential(this, cloner);
+    }
     public Exponential() : base("Exponential", "Symbol that represents the exponential function.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/GreaterThan.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/GreaterThan.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/GreaterThan.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("GreaterThan", "Symbol that represents a greater than relation.")]
   public sealed class GreaterThan : Symbol {
+    [StorableConstructor]
+    private GreaterThan(bool deserializing) : base(deserializing) { }
+    private GreaterThan(GreaterThan original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GreaterThan(this, cloner);
+    }
     public GreaterThan() : base("GreaterThan", "Symbol that represents a greater than relation.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/IfThenElse.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/IfThenElse.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/IfThenElse.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("IfThenElse", "Symbol that represents a conditional operator.")]
   public sealed class IfThenElse : Symbol {
+    [StorableConstructor]
+    private IfThenElse(bool deserializing) : base(deserializing) { }
+    private IfThenElse(IfThenElse original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IfThenElse(this, cloner);
+    }
     public IfThenElse() : base("IfThenElse", "Symbol that represents a conditional operator.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariable.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariable.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariable.cs	(revision 5275)
@@ -40,4 +40,11 @@
       set { maxLag = value; }
     }
+    [StorableConstructor]
+    private LaggedVariable(bool deserializing) : base(deserializing) { }
+    private LaggedVariable(LaggedVariable original, Cloner cloner)
+      : base(original, cloner) {
+      minLag = original.minLag;
+      maxLag = original.maxLag;
+    }
     public LaggedVariable()
       : base("LaggedVariable", "Represents a variable value with a time offset.") {
@@ -50,8 +57,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      LaggedVariable clone = (LaggedVariable)base.Clone(cloner);
-      clone.minLag = minLag;
-      clone.maxLag = maxLag;
-      return clone;
+      return new LaggedVariable(this, cloner);
     }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariableTreeNode.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariableTreeNode.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariableTreeNode.cs	(revision 5275)
@@ -21,4 +21,5 @@
 
 using System;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -36,11 +37,11 @@
     }
 
-    private LaggedVariableTreeNode() { }
-
-    // copy constructor
-    private LaggedVariableTreeNode(LaggedVariableTreeNode original)
-      : base(original) {
+    [StorableConstructor]
+    private LaggedVariableTreeNode(bool deserializing) : base(deserializing) { }
+    private LaggedVariableTreeNode(LaggedVariableTreeNode original, Cloner cloner)
+      : base(original, cloner) {
       lag = original.lag;
     }
+    private LaggedVariableTreeNode() { }
 
     public LaggedVariableTreeNode(LaggedVariable variableSymbol) : base(variableSymbol) { }
@@ -62,7 +63,6 @@
     }
 
-
-    public override object Clone() {
-      return new LaggedVariableTreeNode(this);
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LaggedVariableTreeNode(this, cloner);
     }
 
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LessThan.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LessThan.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LessThan.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("LessThan", "Symbol that represents a less than relation.")]
   public sealed class LessThan : Symbol {
+    [StorableConstructor]
+    private LessThan(bool deserializing) : base(deserializing) { }
+    private LessThan(LessThan original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LessThan(this, cloner);
+    }
     public LessThan() : base("LessThan", "Symbol that represents a less than relation.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Logarithm.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Logarithm.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Logarithm.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Logarithm", "Symbol that represents the logarithm function.")]
   public sealed class Logarithm : Symbol {
+    [StorableConstructor]
+    private Logarithm(bool deserializing) : base(deserializing) { }
+    private Logarithm(Logarithm original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Logarithm(this, cloner);
+    }
     public Logarithm() : base("Logarithm", "Symbol that represents the logarithm function.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Multiplication.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Multiplication.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Multiplication.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Multiplication", "Symbol that represents the * operator.")]
   public sealed class Multiplication : Symbol {
+    [StorableConstructor]
+    private Multiplication(bool deserializing) : base(deserializing) { }
+    private Multiplication(Multiplication original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Multiplication(this, cloner);
+    }
     public Multiplication() : base("Multiplication", "Symbol that represents the * operator.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Not.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Not.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Not.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Not", "Symbol that represents the boolean NOT operator.")]
   public sealed class Not : Symbol {
+    [StorableConstructor]
+    private Not(bool deserializing) : base(deserializing) { }
+    private Not(Not original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Not(this, cloner);
+    }
     public Not() : base("Not", "Symbol that represents the boolean NOT operator.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Or.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Or.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Or.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Or", "Symbol that represents the boolean OR operator.")]
   public sealed class Or : Symbol {
+    [StorableConstructor]
+    private Or(bool deserializing) : base(deserializing) { }
+    private Or(Or original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Or(this, cloner);
+    }
     public Or() : base("Or", "Symbol that represents the boolean OR operator.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Sine.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Sine.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Sine.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Sine", "Symbol that represents the sine function.")]
   public sealed class Sine : Symbol {
+    [StorableConstructor]
+    private Sine(bool deserializing) : base(deserializing) { }
+    private Sine(Sine original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Sine(this, cloner);
+    }
     public Sine() : base("Sine", "Symbol that represents the sine function.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Subtraction.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Subtraction.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Subtraction.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Subtraction", "Symbol that represents the - operator.")]
   public sealed class Subtraction : Symbol {
+    [StorableConstructor]
+    private Subtraction(bool deserializing) : base(deserializing) { }
+    private Subtraction(Subtraction original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Subtraction(this, cloner);
+    }
     public Subtraction() : base("Subtraction", "Symbol that represents the - operator.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Tangent.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Tangent.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Tangent.cs	(revision 5275)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
@@ -27,4 +28,10 @@
   [Item("Tangent", "Symbol that represents the tangent trigonometric function.")]
   public sealed class Tangent : Symbol {
+    [StorableConstructor]
+    private Tangent(bool deserializing) : base(deserializing) { }
+    private Tangent(Tangent original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Tangent(this, cloner);
+    }
     public Tangent() : base("Tangent", "Symbol that represents the tangent trigonometric function.") { }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs	(revision 5275)
@@ -33,10 +33,10 @@
     #region Properties
     [Storable]
-    private double weightNu;
-    public double WeightNu {
-      get { return weightNu; }
+    private double weightMu;
+    public double WeightMu {
+      get { return weightMu; }
       set {
-        if (value != weightNu) {
-          weightNu = value;
+        if (value != weightMu) {
+          weightMu = value;
           OnChanged(EventArgs.Empty);
         }
@@ -56,10 +56,10 @@
     }
     [Storable]
-    private double weightManipulatorNu;
-    public double WeightManipulatorNu {
-      get { return weightManipulatorNu; }
+    private double weightManipulatorMu;
+    public double WeightManipulatorMu {
+      get { return weightManipulatorMu; }
       set {
-        if (value != weightManipulatorNu) {
-          weightManipulatorNu = value;
+        if (value != weightManipulatorMu) {
+          weightManipulatorMu = value;
           OnChanged(EventArgs.Empty);
         }
@@ -90,10 +90,22 @@
     }
     #endregion
+    [StorableConstructor]
+    protected Variable(bool deserializing) : base(deserializing) {
+      variableNames = new List<string>();
+    }
+    protected Variable(Variable original, Cloner cloner)
+      : base(original, cloner) {
+      weightMu = original.weightMu;
+      weightSigma = original.weightSigma;
+      variableNames = new List<string>(original.variableNames);
+      weightManipulatorMu = original.weightManipulatorMu;
+      weightManipulatorSigma = original.weightManipulatorSigma;
+    }
     public Variable() : this("Variable", "Represents a variable value.") { }
     public Variable(string name, string description)
       : base(name, description) {
-      weightNu = 1.0;
+      weightMu = 1.0;
       weightSigma = 1.0;
-      weightManipulatorNu = 0.0;
+      weightManipulatorMu = 0.0;
       weightManipulatorSigma = 1.0;
       variableNames = new List<string>();
@@ -105,11 +117,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      Variable clone = (Variable)base.Clone(cloner);
-      clone.weightNu = weightNu;
-      clone.weightSigma = weightSigma;
-      clone.variableNames = new List<string>(variableNames);
-      clone.weightManipulatorNu = weightManipulatorNu;
-      clone.weightManipulatorSigma = weightManipulatorSigma;
-      return clone;
+      return new Variable(this, cloner);
     }
   }
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs	(revision 4220)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs	(revision 5275)
@@ -20,6 +20,6 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -44,14 +44,12 @@
     }
 
-
-    protected VariableTreeNode() { }
-
-    // copy constructor
-    protected VariableTreeNode(VariableTreeNode original)
-      : base(original) {
+    [StorableConstructor]
+    protected VariableTreeNode(bool deserializing) : base(deserializing) { }
+    protected VariableTreeNode(VariableTreeNode original, Cloner cloner)
+      : base(original, cloner) {
       weight = original.weight;
       variableName = original.variableName;
     }
-
+    protected VariableTreeNode() { }
     public VariableTreeNode(Variable variableSymbol) : base(variableSymbol) { }
 
@@ -64,5 +62,5 @@
     public override void ResetLocalParameters(IRandom random) {
       base.ResetLocalParameters(random);
-      weight = NormalDistributedRandom.NextDouble(random, Symbol.WeightNu, Symbol.WeightSigma);
+      weight = NormalDistributedRandom.NextDouble(random, Symbol.WeightMu, Symbol.WeightSigma);
       variableName = Symbol.VariableNames.SelectRandom(random);
     }
@@ -70,12 +68,11 @@
     public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
       base.ShakeLocalParameters(random, shakingFactor);
-      double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorNu, Symbol.WeightManipulatorSigma);
+      double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorMu, Symbol.WeightManipulatorSigma);
       weight = weight + x * shakingFactor;
       variableName = Symbol.VariableNames.SelectRandom(random);
     }
 
-
-    public override object Clone() {
-      return new VariableTreeNode(this);
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableTreeNode(this, cloner);
     }
 
