Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Analyzers/SymbolicExpressionTreeLengthAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Analyzers/SymbolicExpressionTreeLengthAnalyzer.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Analyzers/SymbolicExpressionTreeLengthAnalyzer.cs	(revision 12422)
@@ -51,4 +51,8 @@
       get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
     }
+
+    public ILookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
+    }
     public ValueLookupParameter<DataTable> SymbolicExpressionTreeLengthsParameter {
       get { return (ValueLookupParameter<DataTable>)Parameters[SymbolicExpressionTreeLengthsParameterName]; }
@@ -178,5 +182,5 @@
         }
 
-        double maximumAllowedTreeLength = ((LookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]).ActualValue.Value;
+        double maximumAllowedTreeLength = MaximumSymbolicExpressionTreeLengthParameter.ActualValue.Value;
 
         treeLengthsTableRow.VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Histogram;
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentCreater.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentCreater.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentCreater.cs	(revision 12422)
@@ -28,4 +28,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -84,11 +85,12 @@
       ISymbolicExpressionTree clonedTree = (ISymbolicExpressionTree)symbolicExpressionTree.Clone();
 
-      var functionDefiningBranches = clonedTree.IterateNodesPrefix().OfType<DefunTreeNode>();
-      if (functionDefiningBranches.Count() == 0)
+      var functionDefiningBranches = clonedTree.IterateNodesPrefix().OfType<DefunTreeNode>().ToList();
+      if (!functionDefiningBranches.Any())
         // no function defining branch found => abort
         return false;
 
       // select a random function defining branch
-      var selectedDefunBranch = functionDefiningBranches.SelectRandom(random);
+      var selectedDefunBranch = functionDefiningBranches.SampleRandom(random);
+
       var definedArguments = (from symbol in selectedDefunBranch.Grammar.Symbols.OfType<Argument>()
                               select symbol.ArgumentIndex).Distinct();
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDeleter.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDeleter.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDeleter.cs	(revision 12422)
@@ -25,4 +25,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -54,9 +55,10 @@
       int maxFunctionDefinitions, int maxFunctionArguments) {
 
-      var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();
-      if (functionDefiningBranches.Count() == 0)
+      var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>().ToList();
+      if (!functionDefiningBranches.Any())
         // no function defining branch => abort
         return false;
-      var selectedDefunBranch = functionDefiningBranches.SelectRandom(random);
+
+      var selectedDefunBranch = functionDefiningBranches.SampleRandom(random);
       if (selectedDefunBranch.NumberOfArguments <= 1)
         // argument deletion by consolidation is not possible => abort
@@ -77,10 +79,10 @@
 
       // delete the dynamic argument symbol that matches the argument to be removed
-      var matchingSymbol = selectedDefunBranch.Grammar.Symbols.OfType<Argument>().Where(s => s.ArgumentIndex == removedArgument).Single();
+      var matchingSymbol = selectedDefunBranch.Grammar.Symbols.OfType<Argument>().Single(s => s.ArgumentIndex == removedArgument);
       selectedDefunBranch.Grammar.RemoveSymbol(matchingSymbol);
       selectedDefunBranch.NumberOfArguments--;
       // reduce arity in known functions of all root branches
       foreach (var subtree in symbolicExpressionTree.Root.Subtrees) {
-        var matchingInvokeSymbol = subtree.Grammar.Symbols.OfType<InvokeFunction>().Where(s => s.FunctionName == selectedDefunBranch.FunctionName).SingleOrDefault();
+        var matchingInvokeSymbol = subtree.Grammar.Symbols.OfType<InvokeFunction>().SingleOrDefault(s => s.FunctionName == selectedDefunBranch.FunctionName);
         if (matchingInvokeSymbol != null) {
           subtree.Grammar.SetSubtreeCount(matchingInvokeSymbol, selectedDefunBranch.NumberOfArguments, selectedDefunBranch.NumberOfArguments);
@@ -99,5 +101,5 @@
                      select node;
       foreach (var argNode in argNodes) {
-        var replacementSymbol = possibleArgumentSymbols.SelectRandom(random);
+        var replacementSymbol = possibleArgumentSymbols.SampleRandom(random);
         argNode.Symbol = replacementSymbol;
       }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDuplicater.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDuplicater.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDuplicater.cs	(revision 12422)
@@ -27,4 +27,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -56,17 +57,19 @@
       ISymbolicExpressionTree symbolicExpressionTree,
       int maxFunctionDefinitions, int maxFunctionArguments) {
-      var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();
+      var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>().ToList();
 
       var allowedArgumentIndexes = Enumerable.Range(0, maxFunctionArguments);
-      if (functionDefiningBranches.Count() == 0)
+      if (!functionDefiningBranches.Any())
         // no function defining branches => abort
         return false;
 
-      var selectedDefunBranch = functionDefiningBranches.SelectRandom(random);
-      var argumentSymbols = selectedDefunBranch.Grammar.Symbols.OfType<Argument>();
-      if (argumentSymbols.Count() == 0 || argumentSymbols.Count() >= maxFunctionArguments)
+      var selectedDefunBranch = functionDefiningBranches.SampleRandom(random);
+
+      var argumentSymbols = selectedDefunBranch.Grammar.Symbols.OfType<Argument>().ToList();
+      if (!argumentSymbols.Any() || argumentSymbols.Count() >= maxFunctionArguments)
         // when no argument or number of arguments is already at max allowed value => abort
         return false;
-      var selectedArgumentSymbol = argumentSymbols.SelectRandom(random);
+
+      var selectedArgumentSymbol = argumentSymbols.SampleRandom(random);
       var takenIndexes = argumentSymbols.Select(s => s.ArgumentIndex);
       var newArgumentIndex = allowedArgumentIndexes.Except(takenIndexes).First();
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs	(revision 12422)
@@ -29,4 +29,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -113,9 +114,10 @@
                           from subtree in parent.Subtrees
                           select new CutPoint(parent, subtree)).ToList();
-      if (allCutPoints.Count() == 0)
+      if (!allCutPoints.Any())
         // no cut points => abort
         return false;
       string newFunctionName = allowedFunctionNames.Except(functionDefiningBranches.Select(x => x.FunctionName)).First();
-      var selectedCutPoint = allCutPoints.SelectRandom(random);
+      var selectedCutPoint = allCutPoints.SampleRandom(random);
+
       // select random branches as argument cut-off points (replaced by argument terminal nodes in the function)
       List<CutPoint> argumentCutPoints = SelectRandomArgumentBranches(selectedCutPoint.Child, random, ARGUMENT_CUTOFF_PROBABILITY, maxFunctionArguments);
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDeleter.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDeleter.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDeleter.cs	(revision 12422)
@@ -26,4 +26,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -55,10 +56,11 @@
       ISymbolicExpressionTree symbolicExpressionTree,
       int maxFunctionDefinitions, int maxFunctionArguments) {
-      var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();
+      var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>().ToList();
 
-      if (functionDefiningBranches.Count() == 0)
+      if (!functionDefiningBranches.Any())
         // no ADF to delete => abort
         return false;
-      var selectedDefunBranch = functionDefiningBranches.SelectRandom(random);
+
+      var selectedDefunBranch = functionDefiningBranches.SampleRandom(random);
       // remove the selected defun
       int defunSubtreeIndex = symbolicExpressionTree.Root.IndexOfSubtree(selectedDefunBranch);
@@ -92,5 +94,9 @@
         var allowedSymbolsList = invocationCutPoint.Parent.Grammar.GetAllowedChildSymbols(invocationCutPoint.Parent.Symbol, invocationCutPoint.ChildIndex).ToList();
         var weights = allowedSymbolsList.Select(s => s.InitialFrequency);
+
+#pragma warning disable 612, 618
         var selectedSymbol = allowedSymbolsList.SelectRandom(weights, random);
+#pragma warning restore 612, 618
+
 
         int minPossibleLength = invocationCutPoint.Parent.Grammar.GetMinimumExpressionLength(selectedSymbol);
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs	(revision 12422)
@@ -28,4 +28,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -59,6 +60,6 @@
       ISymbolicExpressionTree symbolicExpressionTree,
       int maxFunctionDefinitions, int maxFunctionArguments) {
-      var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();
-      if (functionDefiningBranches.Count() == 0 || functionDefiningBranches.Count() == maxFunctionDefinitions)
+      var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>().ToList();
+      if (!functionDefiningBranches.Any() || functionDefiningBranches.Count() == maxFunctionDefinitions)
         // no function defining branches to duplicate or already reached the max number of ADFs
         return false;
@@ -67,5 +68,6 @@
       var allowedFunctionNames = from index in Enumerable.Range(0, maxFunctionDefinitions)
                                  select "ADF" + index.ToString(formatString);
-      var selectedBranch = functionDefiningBranches.SelectRandom(random);
+
+      var selectedBranch = functionDefiningBranches.SampleRandom(random);
       var duplicatedDefunBranch = (DefunTreeNode)selectedBranch.Clone();
       string newFunctionName = allowedFunctionNames.Except(UsedFunctionNames(symbolicExpressionTree)).First();
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/FullTreeCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/FullTreeCreator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/FullTreeCreator.cs	(revision 12422)
@@ -24,6 +24,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
@@ -36,26 +34,4 @@
                                  ISymbolicExpressionTreeSizeConstraintOperator,
                                  ISymbolicExpressionTreeGrammarBasedOperator {
-    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
-    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
-
-    #region Parameter Properties
-    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
-    }
-
-    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
-    }
-    #endregion
-    #region Properties
-    public IntValue MaximumSymbolicExpressionTreeDepth {
-      get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; }
-    }
-
-    public IntValue MaximumSymbolicExpressionTreeLength {
-      get { return MaximumSymbolicExpressionTreeLengthParameter.ActualValue; }
-    }
-
-    #endregion
 
     [StorableConstructor]
@@ -63,11 +39,5 @@
     protected FullTreeCreator(FullTreeCreator original, Cloner cloner) : base(original, cloner) { }
 
-    public FullTreeCreator()
-      : base() {
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName,
-        "The maximal length (number of nodes) of the symbolic expression tree (this parameter is ignored)."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName,
-        "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
-    }
+    public FullTreeCreator() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -77,5 +47,6 @@
 
     protected override ISymbolicExpressionTree Create(IRandom random) {
-      return Create(random, ClonedSymbolicExpressionTreeGrammarParameter.ActualValue, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value);
+      return Create(random, ClonedSymbolicExpressionTreeGrammarParameter.ActualValue,
+          MaximumSymbolicExpressionTreeLengthParameter.ActualValue.Value, MaximumSymbolicExpressionTreeDepthParameter.ActualValue.Value);
     }
 
@@ -131,5 +102,9 @@
           .ToList();
         var weights = possibleSymbols.Select(s => s.InitialFrequency).ToList();
+
+#pragma warning disable 612, 618
         var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
+#pragma warning restore 612, 618
+
         var tree = selectedSymbol.CreateTreeNode();
         if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
@@ -163,5 +138,9 @@
           throw new InvalidOperationException("No symbols are available for the tree.");
         var weights = possibleSymbols.Select(s => s.InitialFrequency).ToList();
+
+#pragma warning disable 612, 618
         var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
+#pragma warning restore 612, 618
+        
         var tree = selectedSymbol.CreateTreeNode();
         if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
@@ -169,7 +148,10 @@
       }
 
-      foreach (var subTree in root.Subtrees)
-        if (subTree.Grammar.GetMaximumSubtreeCount(subTree.Symbol) > 0)
-          RecursiveCreate(random, subTree, currentDepth + 1, maxDepth);
+      //additional levels should only be added if the maximum depth is not reached yet
+      if (maxDepth > currentDepth) {
+        foreach (var subTree in root.Subtrees)
+          if (subTree.Grammar.GetMaximumSubtreeCount(subTree.Symbol) > 0)
+            RecursiveCreate(random, subTree, currentDepth + 1, maxDepth);
+      }
     }
   }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/GrowTreeCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/GrowTreeCreator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/GrowTreeCreator.cs	(revision 12422)
@@ -24,6 +24,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
@@ -33,41 +31,10 @@
   [StorableClass]
   [Item("GrowTreeCreator", "An operator that creates new symbolic expression trees using the 'Grow' method")]
-  public class GrowTreeCreator : SymbolicExpressionTreeCreator,
-                                 ISymbolicExpressionTreeSizeConstraintOperator,
-                                 ISymbolicExpressionTreeGrammarBasedOperator {
-    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
-    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
-
-    #region Parameter Properties
-    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
-    }
-
-    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
-    }
-
-    #endregion
-    #region Properties
-    public IntValue MaximumSymbolicExpressionTreeDepth {
-      get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; }
-    }
-
-    public IntValue MaximumSymbolicExpressionTreeLength {
-      get { return MaximumSymbolicExpressionTreeLengthParameter.ActualValue; }
-    }
-    #endregion
-
+  public class GrowTreeCreator : SymbolicExpressionTreeCreator {
     [StorableConstructor]
     protected GrowTreeCreator(bool deserializing) : base(deserializing) { }
     protected GrowTreeCreator(GrowTreeCreator original, Cloner cloner) : base(original, cloner) { }
 
-    public GrowTreeCreator()
-      : base() {
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName,
-        "The maximal length (number of nodes) of the symbolic expression tree (this parameter is ignored)."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName,
-        "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
-    }
+    public GrowTreeCreator() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -78,5 +45,5 @@
     protected override ISymbolicExpressionTree Create(IRandom random) {
       return Create(random, ClonedSymbolicExpressionTreeGrammarParameter.ActualValue,
-        MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value);
+        MaximumSymbolicExpressionTreeLengthParameter.ActualValue.Value, MaximumSymbolicExpressionTreeDepthParameter.ActualValue.Value);
     }
 
@@ -122,14 +89,14 @@
         throw new ArgumentException("Cannot grow tree. Seed node shouldn't have arity zero.");
 
-      var allowedSymbols = seedNode.Grammar.AllowedSymbols
-        .Where(s => s.InitialFrequency > 0.0)
-        .ToList();
+      var allowedSymbols = seedNode.Grammar.AllowedSymbols.Where(s => s.InitialFrequency > 0.0).ToList();
 
       for (var i = 0; i < arity; i++) {
-        var possibleSymbols = allowedSymbols
-          .Where(s => seedNode.Grammar.IsAllowedChildSymbol(seedNode.Symbol, s, i))
-          .ToList();
+        var possibleSymbols = allowedSymbols.Where(s => seedNode.Grammar.IsAllowedChildSymbol(seedNode.Symbol, s, i)).ToList();
         var weights = possibleSymbols.Select(s => s.InitialFrequency).ToList();
+
+#pragma warning disable 612, 618
         var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
+#pragma warning restore 612, 618
+
         var tree = selectedSymbol.CreateTreeNode();
         if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
@@ -146,19 +113,21 @@
     private static void RecursiveCreate(IRandom random, ISymbolicExpressionTreeNode root, int currentDepth, int maxDepth) {
       var arity = SampleArity(random, root);
-      if (arity <= 0)
-        throw new ArgumentException("Cannot grow node of arity zero. Expected a function node.");
+      if (arity == 0)
+        return;
 
       var allowedSymbols = root.Grammar.AllowedSymbols.Where(s => s.InitialFrequency > 0.0).ToList();
 
       for (var i = 0; i < arity; i++) {
-        var possibleSymbols = allowedSymbols
-          .Where(s => root.Grammar.IsAllowedChildSymbol(root.Symbol, s, i) &&
-            root.Grammar.GetMinimumExpressionDepth(s) - 1 <= maxDepth - currentDepth)
-          .ToList();
+        var possibleSymbols = allowedSymbols.Where(s => root.Grammar.IsAllowedChildSymbol(root.Symbol, s, i) &&
+                                                        root.Grammar.GetMinimumExpressionDepth(s) - 1 <= maxDepth - currentDepth).ToList();
 
         if (!possibleSymbols.Any())
           throw new InvalidOperationException("No symbols are available for the tree.");
+
         var weights = possibleSymbols.Select(s => s.InitialFrequency).ToList();
+#pragma warning disable 612, 618
         var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
+#pragma warning restore 612, 618
+
         var tree = selectedSymbol.CreateTreeNode();
         if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
@@ -166,7 +135,8 @@
       }
 
-      foreach (var subTree in root.Subtrees)
-        if (subTree.Grammar.GetMaximumSubtreeCount(subTree.Symbol) != 0)
-          RecursiveCreate(random, subTree, currentDepth + 1, maxDepth);
+      if (maxDepth > currentDepth)
+        foreach (var subTree in root.Subtrees)
+          if (subTree.Grammar.GetMaximumSubtreeCount(subTree.Symbol) != 0)
+            RecursiveCreate(random, subTree, currentDepth + 1, maxDepth);
     }
 
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs	(revision 12422)
@@ -25,6 +25,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
@@ -37,22 +35,4 @@
     ISymbolicExpressionTreeSizeConstraintOperator, ISymbolicExpressionTreeGrammarBasedOperator {
     private const int MAX_TRIES = 100;
-    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
-    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
-    #region Parameter Properties
-    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
-    }
-    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
-    }
-    #endregion
-    #region Properties
-    public IntValue MaximumSymbolicExpressionTreeLength {
-      get { return MaximumSymbolicExpressionTreeLengthParameter.ActualValue; }
-    }
-    public IntValue MaximumSymbolicExpressionTreeDepth {
-      get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; }
-    }
-    #endregion
 
     [StorableConstructor]
@@ -61,6 +41,5 @@
     public ProbabilisticTreeCreator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "The maximal length (number of nodes) of the symbolic expression tree."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
+
     }
 
@@ -71,5 +50,6 @@
 
     protected override ISymbolicExpressionTree Create(IRandom random) {
-      return Create(random, ClonedSymbolicExpressionTreeGrammarParameter.ActualValue, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value);
+      return Create(random, ClonedSymbolicExpressionTreeGrammarParameter.ActualValue,
+        MaximumSymbolicExpressionTreeLengthParameter.ActualValue.Value, MaximumSymbolicExpressionTreeDepthParameter.ActualValue.Value);
     }
 
@@ -186,5 +166,9 @@
           if (allowedSymbols.Count == 0) return false;
           var weights = allowedSymbols.Select(x => x.InitialFrequency).ToList();
+
+#pragma warning disable 612, 618
           var selectedSymbol = allowedSymbols.SelectRandom(weights, random);
+#pragma warning restore 612, 618
+
           ISymbolicExpressionTreeNode newTree = selectedSymbol.CreateTreeNode();
           if (newTree.HasLocalParameters) newTree.ResetLocalParameters(random);
@@ -232,5 +216,9 @@
                              select g).First().ToList();
       var weights = possibleSymbols.Select(x => x.InitialFrequency).ToList();
+
+#pragma warning disable 612, 618
       var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
+#pragma warning restore 612, 618
+
       var tree = selectedSymbol.CreateTreeNode();
       if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/RampedHalfAndHalfTreeCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/RampedHalfAndHalfTreeCreator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/RampedHalfAndHalfTreeCreator.cs	(revision 12422)
@@ -22,6 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
@@ -31,41 +29,10 @@
   [StorableClass]
   [Item("RampedHalfAndHalfTreeCreator", "An operator that creates new symbolic expression trees in an alternate way: half the trees are created usign the 'Grow' method while the other half are created using the 'Full' method")]
-  public class RampedHalfAndHalfTreeCreator : SymbolicExpressionTreeCreator,
-                                 ISymbolicExpressionTreeSizeConstraintOperator,
-                                 ISymbolicExpressionTreeGrammarBasedOperator {
-    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
-    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
-
-    #region Parameter Properties
-    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
-    }
-
-    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
-    }
-
-    #endregion
-    #region Properties
-    public IntValue MaximumSymbolicExpressionTreeDepth {
-      get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; }
-    }
-
-    public IntValue MaximumSymbolicExpressionTreeLength {
-      get { return MaximumSymbolicExpressionTreeLengthParameter.ActualValue; }
-    }
-    #endregion
-
+  public class RampedHalfAndHalfTreeCreator : SymbolicExpressionTreeCreator {
     [StorableConstructor]
     protected RampedHalfAndHalfTreeCreator(bool deserializing) : base(deserializing) { }
     protected RampedHalfAndHalfTreeCreator(RampedHalfAndHalfTreeCreator original, Cloner cloner) : base(original, cloner) { }
 
-    public RampedHalfAndHalfTreeCreator()
-      : base() {
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName,
-        "The maximal length (number of nodes) of the symbolic expression tree (this parameter is ignored)."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName,
-        "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
-    }
+    public RampedHalfAndHalfTreeCreator() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -74,5 +41,6 @@
 
     protected override ISymbolicExpressionTree Create(IRandom random) {
-      return Create(random, ClonedSymbolicExpressionTreeGrammarParameter.ActualValue, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value);
+      return Create(random, ClonedSymbolicExpressionTreeGrammarParameter.ActualValue,
+        MaximumSymbolicExpressionTreeLengthParameter.ActualValue.Value, MaximumSymbolicExpressionTreeDepthParameter.ActualValue.Value);
     }
 
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/SymbolicExpressionTreeCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/SymbolicExpressionTreeCreator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/SymbolicExpressionTreeCreator.cs	(revision 12422)
@@ -22,4 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -32,13 +33,17 @@
   [StorableClass]
   public abstract class SymbolicExpressionTreeCreator : SymbolicExpressionTreeOperator, ISymbolicExpressionTreeCreator {
-    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
+    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
+
     private const string SymbolicExpressionTreeGrammarParameterName = "SymbolicExpressionTreeGrammar";
     private const string ClonedSymbolicExpressionTreeGrammarParameterName = "ClonedSymbolicExpressionTreeGrammar";
 
     #region Parameter Properties
-    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
-      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
     }
-
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
+    }
     public IValueLookupParameter<ISymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter {
       get { return (IValueLookupParameter<ISymbolicExpressionGrammar>)Parameters[SymbolicExpressionTreeGrammarParameterName]; }
@@ -55,9 +60,8 @@
     protected SymbolicExpressionTreeCreator()
       : base() {
-      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree that should be created."));
-      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName,
-        "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));
-      Parameters.Add(new LookupParameter<ISymbolicExpressionGrammar>(ClonedSymbolicExpressionTreeGrammarParameterName,
-        "An immutable clone of the concrete grammar that is actually used to create and manipulate trees."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "The maximal length (number of nodes) of the symbolic expression tree."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
+      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName, "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionGrammar>(ClonedSymbolicExpressionTreeGrammarParameterName, "An immutable clone of the concrete grammar that is actually used to create and manipulate trees."));
     }
 
@@ -78,5 +82,5 @@
           (ISymbolicExpressionGrammar)SymbolicExpressionTreeGrammarParameter.ActualValue.Clone()));
       }
-      SymbolicExpressionTreeParameter.ActualValue = Create(Random);
+      SymbolicExpressionTreeParameter.ActualValue = Create(RandomParameter.ActualValue);
       return base.InstrumentedApply();
     }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs	(revision 12422)
@@ -28,4 +28,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -181,5 +182,6 @@
                                    select branch).ToList();
         if (allowedInternalBranches.Count > 0) {
-          return allowedInternalBranches.SelectRandom(random);
+          return allowedInternalBranches.SampleRandom(random);
+
         } else {
           // no internal nodes allowed => select leaf nodes
@@ -187,5 +189,5 @@
                                  where branch == null || branch.SubtreeCount == 0
                                  select branch).ToList();
-          return allowedLeafBranches.SelectRandom(random);
+          return allowedLeafBranches.SampleRandom(random);
         }
       } else {
@@ -195,10 +197,11 @@
                                select branch).ToList();
         if (allowedLeafBranches.Count > 0) {
-          return allowedLeafBranches.SelectRandom(random);
+          return allowedLeafBranches.SampleRandom(random);
         } else {
           allowedInternalBranches = (from branch in branches
                                      where branch != null && branch.SubtreeCount > 0
                                      select branch).ToList();
-          return allowedInternalBranches.SelectRandom(random);
+          return allowedInternalBranches.SampleRandom(random);
+
         }
       }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs	(revision 12422)
@@ -34,20 +34,16 @@
   public abstract class SymbolicExpressionTreeCrossover : SymbolicExpressionTreeOperator, ISymbolicExpressionTreeCrossover {
     private const string ParentsParameterName = "Parents";
-    private const string ChildParameterName = "Child";
     #region Parameter Properties
     public ILookupParameter<ItemArray<ISymbolicExpressionTree>> ParentsParameter {
       get { return (ScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[ParentsParameterName]; }
     }
-    public ILookupParameter<ISymbolicExpressionTree> ChildParameter {
-      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[ChildParameterName]; }
-    }
     #endregion
     #region Properties
-    public ItemArray<ISymbolicExpressionTree> Parents {
+    private ItemArray<ISymbolicExpressionTree> Parents {
       get { return ParentsParameter.ActualValue; }
     }
-    public ISymbolicExpressionTree Child {
-      get { return ChildParameter.ActualValue; }
-      set { ChildParameter.ActualValue = value; }
+    private ISymbolicExpressionTree Child {
+      get { return SymbolicExpressionTreeParameter.ActualValue; }
+      set { SymbolicExpressionTreeParameter.ActualValue = value; }
     }
     #endregion
@@ -58,7 +54,5 @@
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(ParentsParameterName, "The parent symbolic expression trees which should be crossed."));
-      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(ChildParameterName, "The child symbolic expression tree resulting from the crossover."));
       ParentsParameter.ActualName = "SymbolicExpressionTree";
-      ChildParameter.ActualName = "SymbolicExpressionTree";
     }
 
@@ -67,5 +61,5 @@
         throw new ArgumentException("Number of parents must be exactly two for symbolic expression tree crossover operators.");
 
-      ISymbolicExpressionTree result = Crossover(Random, Parents[0], Parents[1]);
+      ISymbolicExpressionTree result = Crossover(RandomParameter.ActualValue, Parents[0], Parents[1]);
 
       Child = result;
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/EnumerableExtensions.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/EnumerableExtensions.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/EnumerableExtensions.cs	(revision 12422)
@@ -20,11 +20,16 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Core;
-using System;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
+
+  //This class should not be used anymore. Use HeuristicLab.Random.RandomEnumberable instead
+  //This could not be fixed right now, because the algorithm behavior would be modified => version increment
+  [Obsolete("This class will be removed in the future, because the functionality is provided in HeuristicLab.Random.RandomEnumerable.")]
   public static class EnumerableExtensions {
+    [Obsolete("This method should not be used anymore. Use the extensions provided by HeuristicLab.Random.RandomEnumberable instead.")]
     public static T SelectRandom<T>(this IEnumerable<T> xs, IRandom random) {
       var list = xs as IList<T>;
@@ -36,4 +41,5 @@
       }
     }
+    [Obsolete("This method should not be used anymore. Use the extensions provided by HeuristicLab.Random.RandomEnumberable instead.")]
     public static T SelectRandom<T>(this IEnumerable<T> xs, IEnumerable<double> weights, IRandom random) {
       var list = xs as IList<T>;
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/EmptySymbolicExpressionTreeGrammar.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/EmptySymbolicExpressionTreeGrammar.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/EmptySymbolicExpressionTreeGrammar.cs	(revision 12422)
@@ -37,5 +37,5 @@
 
     [StorableConstructor]
-    private EmptySymbolicExpressionTreeGrammar(bool deserializing) : base(deserializing) {}
+    private EmptySymbolicExpressionTreeGrammar(bool deserializing) : base(deserializing) { }
     internal EmptySymbolicExpressionTreeGrammar(ISymbolicExpressionGrammar grammar)
       : base() {
@@ -70,9 +70,9 @@
     }
 
-    IEnumerable<ISymbol> ISymbolicExpressionGrammarBase.GetAllowedChildSymbols(ISymbol parent) {
+    public IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent) {
       return grammar.GetAllowedChildSymbols(parent);
     }
 
-    IEnumerable<ISymbol> ISymbolicExpressionGrammarBase.GetAllowedChildSymbols(ISymbol parent, int argumentIndex) {
+    public IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent, int argumentIndex) {
       return grammar.GetAllowedChildSymbols(parent, argumentIndex);
     }
@@ -85,58 +85,38 @@
     }
 
-    int ISymbolicExpressionGrammarBase.GetMinimumExpressionDepth(ISymbol symbol) {
+    public int GetMinimumExpressionDepth(ISymbol symbol) {
       return grammar.GetMinimumExpressionDepth(symbol);
     }
-    int ISymbolicExpressionGrammarBase.GetMaximumExpressionDepth(ISymbol symbol) {
+    public int GetMaximumExpressionDepth(ISymbol symbol) {
       return grammar.GetMaximumExpressionDepth(symbol);
     }
-    int ISymbolicExpressionGrammarBase.GetMinimumExpressionLength(ISymbol symbol) {
+    public int GetMinimumExpressionLength(ISymbol symbol) {
       return grammar.GetMinimumExpressionLength(symbol);
     }
-    int ISymbolicExpressionGrammarBase.GetMaximumExpressionLength(ISymbol symbol, int maxDepth) {
+    public int GetMaximumExpressionLength(ISymbol symbol, int maxDepth) {
       return grammar.GetMaximumExpressionLength(symbol, maxDepth);
     }
 
+    public void AddSymbol(ISymbol symbol) { throw new NotSupportedException(); }
+    public void RemoveSymbol(ISymbol symbol) { throw new NotSupportedException(); }
+    public void AddAllowedChildSymbol(ISymbol parent, ISymbol child) { throw new NotSupportedException(); }
+    public void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) { throw new NotSupportedException(); }
+    public void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) { throw new NotSupportedException(); }
+    public void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) { throw new NotSupportedException(); }
+    public void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) { throw new NotSupportedException(); }
+
 
     #region ISymbolicExpressionTreeGrammar Members
-    IEnumerable<ISymbol> ISymbolicExpressionTreeGrammar.ModifyableSymbols {
+    public IEnumerable<ISymbol> ModifyableSymbols {
       get { return Enumerable.Empty<ISymbol>(); }
     }
 
-    bool ISymbolicExpressionTreeGrammar.IsModifyableSymbol(ISymbol symbol) {
+    public bool IsModifyableSymbol(ISymbol symbol) {
       return false;
     }
 
-    void ISymbolicExpressionTreeGrammar.AddSymbol(ISymbol symbol) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.RemoveSymbol(ISymbol symbol) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      throw new NotSupportedException();
-    }
-
-    void ISymbolicExpressionTreeGrammar.SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
-      throw new NotSupportedException();
-    }
-    
-    #pragma warning disable 0067 //disable usage warning
+#pragma warning disable 0067 //disable usage warning
     public event EventHandler Changed;
-    #pragma warning restore 0067
+#pragma warning restore 0067
     #endregion
   }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SimpleSymbolicExpressionGrammar.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SimpleSymbolicExpressionGrammar.cs	(revision 12422)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SimpleSymbolicExpressionGrammar.cs	(revision 12422)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
+  public sealed class SimpleSymbolicExpressionGrammar : SymbolicExpressionGrammar {
+    [StorableConstructor]
+    private SimpleSymbolicExpressionGrammar(bool deserializing) : base(deserializing) { }
+    private SimpleSymbolicExpressionGrammar(SimpleSymbolicExpressionGrammar original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SimpleSymbolicExpressionGrammar(this, cloner);
+    }
+
+    public SimpleSymbolicExpressionGrammar()
+      : base("Simple Grammar", "A simple grammar containing symbols that differ only in their name.") {
+    }
+
+    public void AddSymbol(string symbolName, int minimumArity, int maximumArity) {
+      AddSymbol(symbolName, string.Empty, minimumArity, maximumArity);
+    }
+    public void AddSymbol(string symbolName, string description, int minimumArity, int maximumArity) {
+      var symbol = new SimpleSymbol(symbolName, description, minimumArity, maximumArity);
+      AddSymbol(symbol);
+      SetSubtreeCount(symbol, symbol.MinimumArity, symbol.MaximumArity);
+
+      foreach (var s in Symbols) {
+        if (s == ProgramRootSymbol) continue;
+        if (s.MaximumArity > 0) AddAllowedChildSymbol(s, symbol);
+
+        if (s == DefunSymbol) continue;
+        if (s == StartSymbol) continue;
+        if (symbol.MaximumArity > 0) AddAllowedChildSymbol(symbol, s);
+      }
+    }
+    public void AddSymbols(IEnumerable<string> symbolNames, int minimumArity, int maximiumArity) {
+      foreach (var symbolName in symbolNames) AddSymbol(symbolName, minimumArity, maximiumArity);
+    }
+
+    public void AddTerminalSymbol(string symbolName) {
+      AddTerminalSymbol(symbolName, string.Empty);
+    }
+    public void AddTerminalSymbol(string symbolName, string description) {
+      AddSymbol(symbolName, description, 0, 0);
+    }
+    public void AddTerminalSymbols(IEnumerable<string> symbolNames) {
+      foreach (var symbolName in symbolNames) AddTerminalSymbol(symbolName);
+    }
+
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammar.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammar.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammar.cs	(revision 12422)
@@ -177,10 +177,12 @@
     }
 
-    protected override sealed void AddSymbol(ISymbol symbol) {
+    public override sealed void AddSymbol(ISymbol symbol) {
+      if (ReadOnly) throw new InvalidOperationException();
       base.AddSymbol(symbol);
       RegisterSymbolEvents(symbol);
       OnChanged();
     }
-    protected override sealed void RemoveSymbol(ISymbol symbol) {
+    public override sealed void RemoveSymbol(ISymbol symbol) {
+      if (ReadOnly) throw new InvalidOperationException();
       DeregisterSymbolEvents(symbol);
       base.RemoveSymbol(symbol);
@@ -204,32 +206,22 @@
     #endregion
 
-    #region ISymbolicExpressionGrammar methods
-    void ISymbolicExpressionGrammar.AddSymbol(ISymbol symbol) {
-      if (ReadOnly) throw new InvalidOperationException();
-      AddSymbol(symbol);
-    }
-    void ISymbolicExpressionGrammar.RemoveSymbol(ISymbol symbol) {
-      if (ReadOnly) throw new InvalidOperationException();
-      RemoveSymbol(symbol);
-    }
-
-    void ISymbolicExpressionGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
+    public sealed override void AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
       if (ReadOnly) throw new InvalidOperationException();
       base.AddAllowedChildSymbol(parent, child);
     }
-    void ISymbolicExpressionGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+    public sealed override void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
       if (ReadOnly) throw new InvalidOperationException();
       base.AddAllowedChildSymbol(parent, child, argumentIndex);
     }
-    void ISymbolicExpressionGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
+    public sealed override void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
       if (ReadOnly) throw new InvalidOperationException();
       base.RemoveAllowedChildSymbol(parent, child);
     }
-    void ISymbolicExpressionGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+    public sealed override void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
       if (ReadOnly) throw new InvalidOperationException();
       base.RemoveAllowedChildSymbol(parent, child, argumentIndex);
     }
 
-    void ISymbolicExpressionGrammar.SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
+    public sealed override void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
       if (ReadOnly) throw new InvalidOperationException();
       base.SetSubtreeCount(symbol, minimumSubtreeCount, maximumSubtreeCount);
@@ -237,17 +229,16 @@
 
     private bool suppressEvents = false;
-    void ISymbolicExpressionGrammar.StartGrammarManipulation() {
+    public void StartGrammarManipulation() {
       suppressEvents = true;
     }
-    void ISymbolicExpressionGrammar.FinishedGrammarManipulation() {
+    public void FinishedGrammarManipulation() {
       suppressEvents = false;
       OnChanged();
     }
 
-    protected override void OnChanged() {
+    protected sealed override void OnChanged() {
       if (suppressEvents) return;
       base.OnChanged();
     }
-    #endregion
 
     #region symbol events
@@ -305,5 +296,5 @@
     private void Symbol_NameChanged(object sender, EventArgs e) {
       ISymbol symbol = (ISymbol)sender;
-      string oldName = symbols.Where(x => x.Value == symbol).First().Key;
+      string oldName = symbols.First(x => x.Value == symbol).Key;
       string newName = symbol.Name;
 
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammarBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammarBase.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammarBase.cs	(revision 12422)
@@ -41,5 +41,5 @@
     private IEnumerable<ISymbol> StorableSymbols {
       get { return symbols.Values.ToArray(); }
-      set { symbols = value.ToDictionary(sym => sym.Name); }
+      set { foreach (var s in value) symbols.Add(s.Name, s); }
     }
 
@@ -47,5 +47,5 @@
     private IEnumerable<KeyValuePair<ISymbol, Tuple<int, int>>> StorableSymbolSubtreeCount {
       get { return symbolSubtreeCount.Select(x => new KeyValuePair<ISymbol, Tuple<int, int>>(GetSymbol(x.Key), x.Value)).ToArray(); }
-      set { symbolSubtreeCount = value.ToDictionary(x => x.Key.Name, x => x.Value); }
+      set { foreach (var pair in value) symbolSubtreeCount.Add(pair.Key.Name, pair.Value); }
     }
 
@@ -53,19 +53,22 @@
     private IEnumerable<KeyValuePair<ISymbol, IEnumerable<ISymbol>>> StorableAllowedChildSymbols {
       get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(GetSymbol).ToArray())).ToArray(); }
-      set { allowedChildSymbols = value.ToDictionary(x => x.Key.Name, x => x.Value.Select(y => y.Name).ToList()); }
+      set { foreach (var pair in value) allowedChildSymbols.Add(pair.Key.Name, pair.Value.Select(y => y.Name).ToList()); }
     }
 
     [Storable(Name = "AllowedChildSymbolsPerIndex")]
     private IEnumerable<KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>> StorableAllowedChildSymbolsPerIndex {
-      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create<ISymbol, int>(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(y => GetSymbol(y)).ToArray())).ToArray(); }
-      set { allowedChildSymbolsPerIndex = value.ToDictionary(x => Tuple.Create(x.Key.Item1.Name, x.Key.Item2), x => x.Value.Select(y => y.Name).ToList()); }
+      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(GetSymbol).ToArray())).ToArray(); }
+      set {
+        foreach (var pair in value)
+          allowedChildSymbolsPerIndex.Add(Tuple.Create(pair.Key.Item1.Name, pair.Key.Item2), pair.Value.Select(y => y.Name).ToList());
+      }
     }
     #endregion
 
     private bool suppressEvents;
-    protected Dictionary<string, ISymbol> symbols;
-    protected Dictionary<string, Tuple<int, int>> symbolSubtreeCount;
-    protected Dictionary<string, List<string>> allowedChildSymbols;
-    protected Dictionary<Tuple<string, int>, List<string>> allowedChildSymbolsPerIndex;
+    protected readonly Dictionary<string, ISymbol> symbols;
+    protected readonly Dictionary<string, Tuple<int, int>> symbolSubtreeCount;
+    protected readonly Dictionary<string, List<string>> allowedChildSymbols;
+    protected readonly Dictionary<Tuple<string, int>, List<string>> allowedChildSymbolsPerIndex;
 
     public override bool CanChangeName {
@@ -87,4 +90,9 @@
       cachedIsAllowedChildSymbolIndex = new Dictionary<Tuple<string, string, int>, bool>();
 
+      symbols = new Dictionary<string, ISymbol>();
+      symbolSubtreeCount = new Dictionary<string, Tuple<int, int>>();
+      allowedChildSymbols = new Dictionary<string, List<string>>();
+      allowedChildSymbolsPerIndex = new Dictionary<Tuple<string, int>, List<string>>();
+
       suppressEvents = false;
     }
@@ -133,5 +141,5 @@
 
     #region protected grammar manipulation methods
-    protected virtual void AddSymbol(ISymbol symbol) {
+    public virtual void AddSymbol(ISymbol symbol) {
       if (ContainsSymbol(symbol)) throw new ArgumentException("Symbol " + symbol + " is already defined.");
       foreach (var s in symbol.Flatten()) {
@@ -143,5 +151,5 @@
     }
 
-    protected virtual void RemoveSymbol(ISymbol symbol) {
+    public virtual void RemoveSymbol(ISymbol symbol) {
       foreach (var s in symbol.Flatten()) {
         symbols.Remove(s.Name);
@@ -175,5 +183,5 @@
     }
 
-    protected void AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
+    public virtual void AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
       bool changed = false;
 
@@ -204,5 +212,5 @@
     }
 
-    protected void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+    public virtual void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
       bool changed = false;
 
@@ -238,5 +246,5 @@
     }
 
-    protected void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
+    public virtual void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
       bool changed = false;
       List<string> childSymbols;
@@ -257,5 +265,5 @@
     }
 
-    protected void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+    public virtual void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
       bool changed = false;
 
@@ -282,5 +290,5 @@
     }
 
-    protected void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
+    public virtual void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
       var symbols = symbol.Flatten().Where(s => !(s is GroupSymbol));
       if (symbols.Any(s => s.MinimumArity > minimumSubtreeCount)) throw new ArgumentException("Invalid minimum subtree count " + minimumSubtreeCount + " for " + symbol);
@@ -308,5 +316,5 @@
     }
     public virtual IEnumerable<ISymbol> AllowedSymbols {
-      get { foreach (var s in Symbols) if (s.Enabled) yield return s; }
+      get { return Symbols.Where(s => s.Enabled); }
     }
     public virtual bool ContainsSymbol(ISymbol symbol) {
@@ -510,5 +518,5 @@
       if (suppressEvents) return;
       var handler = Changed;
-      if (handler != null) Changed(this, EventArgs.Empty);
+      if (handler != null) handler(this, EventArgs.Empty);
     }
   }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionTreeGrammar.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionTreeGrammar.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionTreeGrammar.cs	(revision 12422)
@@ -55,7 +55,4 @@
       }
     }
-    public override IEnumerable<ISymbol> AllowedSymbols {
-      get { return base.AllowedSymbols; }
-    }
     public IEnumerable<ISymbol> ModifyableSymbols {
       get { return base.symbols.Values; }
@@ -76,9 +73,7 @@
     }
 
-    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      return grammar.IsAllowedChildSymbol(parent, child) || base.IsAllowedChildSymbol(parent, child);
-    }
-    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      return grammar.IsAllowedChildSymbol(parent, child, argumentIndex) || base.IsAllowedChildSymbol(parent, child, argumentIndex);
+    public override void RemoveSymbol(ISymbol symbol) {
+      if (!IsModifyableSymbol(symbol)) throw new InvalidOperationException();
+      base.RemoveSymbol(symbol);
     }
 
@@ -91,47 +86,15 @@
       return base.GetMaximumSubtreeCount(symbol);
     }
-
-    void ISymbolicExpressionTreeGrammar.AddSymbol(ISymbol symbol) {
-      base.AddSymbol(symbol);
-    }
-    void ISymbolicExpressionTreeGrammar.RemoveSymbol(ISymbol symbol) {
-      if (!IsModifyableSymbol(symbol)) throw new InvalidOperationException();
-      base.RemoveSymbol(symbol);
-    }
-    void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      base.AddAllowedChildSymbol(parent, child);
-    }
-    void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      base.AddAllowedChildSymbol(parent, child, argumentIndex);
-    }
-    void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
-      base.RemoveAllowedChildSymbol(parent, child);
-    }
-    void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
-      base.RemoveAllowedChildSymbol(parent, child, argumentIndex);
-    }
-
-    void ISymbolicExpressionTreeGrammar.SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
+    public override void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
       if (!IsModifyableSymbol(symbol)) throw new InvalidOperationException();
       base.SetSubtreeCount(symbol, minimumSubtreeCount, maximumSubtreeCount);
     }
 
-    int ISymbolicExpressionGrammarBase.GetMinimumExpressionDepth(ISymbol symbol) {
-      if (symbols.Count == 0) return grammar.GetMinimumExpressionDepth(symbol);
-      else return base.GetMinimumExpressionDepth(symbol);
+    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child) {
+      return grammar.IsAllowedChildSymbol(parent, child) || base.IsAllowedChildSymbol(parent, child);
     }
-    int ISymbolicExpressionGrammarBase.GetMaximumExpressionDepth(ISymbol symbol) {
-      if (symbols.Count == 0) return grammar.GetMaximumExpressionDepth(symbol);
-      else return base.GetMaximumExpressionDepth(symbol);
+    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
+      return grammar.IsAllowedChildSymbol(parent, child, argumentIndex) || base.IsAllowedChildSymbol(parent, child, argumentIndex);
     }
-    int ISymbolicExpressionGrammarBase.GetMinimumExpressionLength(ISymbol symbol) {
-      if (symbols.Count == 0) return grammar.GetMinimumExpressionLength(symbol);
-      else return base.GetMinimumExpressionLength(symbol);
-    }
-    int ISymbolicExpressionGrammarBase.GetMaximumExpressionLength(ISymbol symbol, int maxDepth) {
-      if (symbols.Count == 0) return grammar.GetMaximumExpressionLength(symbol, maxDepth);
-      else return base.GetMaximumExpressionLength(symbol, maxDepth);
-    }
-
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj	(revision 12422)
@@ -176,4 +176,5 @@
     <Compile Include="Grammars\SymbolicExpressionGrammar.cs" />
     <Compile Include="Grammars\SymbolicExpressionTreeGrammar.cs" />
+    <Compile Include="SymbolicExpressionTreeEncoding.cs" />
     <Compile Include="SymbolicExpressionTreeTopLevelNode.cs" />
     <Compile Include="Crossovers\SubtreeCrossover.cs">
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammar.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammar.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammar.cs	(revision 12422)
@@ -36,14 +36,4 @@
     event EventHandler ReadOnlyChanged;
 
-    void AddSymbol(ISymbol symbol);
-    void RemoveSymbol(ISymbol symbol);
-
-    void AddAllowedChildSymbol(ISymbol parent, ISymbol child);
-    void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
-    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child);
-    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
-
-    void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount);
-
     void StartGrammarManipulation();
     void FinishedGrammarManipulation();
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammarBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammarBase.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionGrammarBase.cs	(revision 12422)
@@ -27,7 +27,11 @@
   public interface ISymbolicExpressionGrammarBase : INamedItem {
     IEnumerable<ISymbol> Symbols { get; }
+    IEnumerable<ISymbol> AllowedSymbols { get; }
+
+    bool ContainsSymbol(ISymbol symbol);
     ISymbol GetSymbol(string symbolName);
-    IEnumerable<ISymbol> AllowedSymbols { get; }
-    bool ContainsSymbol(ISymbol symbol);
+
+    void AddSymbol(ISymbol symbol);
+    void RemoveSymbol(ISymbol symbol);
 
     bool IsAllowedChildSymbol(ISymbol parent, ISymbol child);
@@ -36,6 +40,13 @@
     IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent, int argumentIndex);
 
+    void AddAllowedChildSymbol(ISymbol parent, ISymbol child);
+    void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
+    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child);
+    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
+
+
     int GetMinimumSubtreeCount(ISymbol symbol);
     int GetMaximumSubtreeCount(ISymbol symbol);
+    void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount);
 
     int GetMinimumExpressionDepth(ISymbol start);
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeGrammar.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeGrammar.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeGrammar.cs	(revision 12422)
@@ -23,16 +23,6 @@
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
   public interface ISymbolicExpressionTreeGrammar : ISymbolicExpressionGrammarBase {
-
     IEnumerable<ISymbol> ModifyableSymbols { get; }
     bool IsModifyableSymbol(ISymbol symbol);
-    void AddSymbol(ISymbol symbol);
-    void RemoveSymbol(ISymbol symbol);
-
-    void AddAllowedChildSymbol(ISymbol parent, ISymbol child);
-    void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
-    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child);
-    void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex);
-
-    void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeCreator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeCreator.cs	(revision 12422)
@@ -27,6 +27,5 @@
   /// Interface for operators that create symbolic expression trees.
   /// </summary>
-  public interface ISymbolicExpressionTreeCreator : ISymbolicExpressionTreeOperator, ISolutionCreator {
-    ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
+  public interface ISymbolicExpressionTreeCreator : ISolutionCreator, ISymbolicExpressionTreeSizeConstraintOperator, ISymbolicExpressionTreeGrammarBasedOperator {
     ISymbolicExpressionTree CreateTree(IRandom random, ISymbolicExpressionGrammar grammar, int maxTreeLength, int maxTreeDepth);
   }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeCrossover.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeCrossover.cs	(revision 12422)
@@ -29,5 +29,4 @@
   public interface ISymbolicExpressionTreeCrossover : ISymbolicExpressionTreeOperator, ICrossover {
     ILookupParameter<ItemArray<ISymbolicExpressionTree>> ParentsParameter { get; }
-    ILookupParameter<ISymbolicExpressionTree> ChildParameter { get; }
     ISymbolicExpressionTree Crossover(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1);
   }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeManipulator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeManipulator.cs	(revision 12422)
@@ -28,5 +28,4 @@
   /// </summary>
   public interface ISymbolicExpressionTreeManipulator : ISymbolicExpressionTreeOperator, IManipulator {
-    ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeOperator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/Operators/ISymbolicExpressionTreeOperator.cs	(revision 12422)
@@ -27,4 +27,5 @@
   /// </summary>
   public interface ISymbolicExpressionTreeOperator : IOperator {
+    ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ChangeNodeTypeManipulation.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ChangeNodeTypeManipulation.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ChangeNodeTypeManipulation.cs	(revision 12422)
@@ -20,9 +20,9 @@
 #endregion
 
+using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System.Collections.Generic;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -53,5 +53,9 @@
       int tries = 0;
       do {
+
+#pragma warning disable 612, 618
         parent = symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1).Where(n => n.SubtreeCount > 0).SelectRandom(random);
+#pragma warning restore 612, 618
+
         childIndex = random.Next(parent.SubtreeCount);
 
@@ -81,5 +85,7 @@
       if (tries < MAX_TRIES) {
         var weights = allowedSymbols.Select(s => s.InitialFrequency).ToList();
+#pragma warning disable 612, 618
         var newSymbol = allowedSymbols.SelectRandom(weights, random);
+#pragma warning restore 612, 618
 
         // replace the old node with the new node
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs	(revision 12422)
@@ -20,11 +20,11 @@
 #endregion
 
-using System.Linq;
+using System.Collections.Generic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Parameters;
-using System.Collections.Generic;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -66,5 +66,5 @@
       });
       if (parametricNodes.Count > 0) {
-        var selectedPoint = parametricNodes.SelectRandom(random);
+        var selectedPoint = parametricNodes.SampleRandom(random);
         selectedPoint.ShakeLocalParameters(random, shakingFactor);
       }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/RemoveBranchManipulation.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/RemoveBranchManipulation.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/RemoveBranchManipulation.cs	(revision 12422)
@@ -27,4 +27,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -80,5 +81,6 @@
       var nodes = symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1).Where(n => n.SubtreeCount > 0).ToList();
       do {
-        parent = nodes.SelectRandom(random);
+        parent = nodes.SampleRandom(random);
+
         childIndex = random.Next(parent.SubtreeCount);
         var child = parent.GetSubtree(childIndex);
@@ -111,5 +113,9 @@
                              select g).First().ToList();
       var weights = possibleSymbols.Select(x => x.InitialFrequency).ToList();
+
+#pragma warning disable 612, 618
       var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
+#pragma warning restore 612, 618
+
       var newTreeNode = selectedSymbol.CreateTreeNode();
       if (newTreeNode.HasLocalParameters) newTreeNode.ResetLocalParameters(random);
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ReplaceBranchManipulation.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ReplaceBranchManipulation.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ReplaceBranchManipulation.cs	(revision 12422)
@@ -20,4 +20,5 @@
 #endregion
 
+using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
@@ -26,5 +27,4 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System.Collections.Generic;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -78,5 +78,8 @@
       int tries = 0;
       do {
+#pragma warning disable 612, 618
         parent = symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1).Where(n => n.SubtreeCount > 0).SelectRandom(random);
+#pragma warning restore 612, 618
+
         childIndex = random.Next(parent.SubtreeCount);
         var child = parent.GetSubtree(childIndex);
@@ -99,5 +102,8 @@
       if (tries < MAX_TRIES) {
         var weights = allowedSymbols.Select(s => s.InitialFrequency).ToList();
+#pragma warning disable 612, 618
         var seedSymbol = allowedSymbols.SelectRandom(weights, random);
+#pragma warning restore 612, 618
+
         // replace the old node with the new node
         var seedNode = seedSymbol.CreateTreeNode();
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/SymbolicExpressionTreeManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/SymbolicExpressionTreeManipulator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/SymbolicExpressionTreeManipulator.cs	(revision 12422)
@@ -32,18 +32,4 @@
   [StorableClass]
   public abstract class SymbolicExpressionTreeManipulator : SymbolicExpressionTreeOperator, ISymbolicExpressionTreeManipulator {
-    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
-
-    #region Parameter Properties
-    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
-      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
-    }
-    #endregion
-
-    #region Properties
-    public ISymbolicExpressionTree SymbolicExpressionTree {
-      get { return SymbolicExpressionTreeParameter.ActualValue; }
-    }
-    #endregion
-
     [StorableConstructor]
     protected SymbolicExpressionTreeManipulator(bool deserializing) : base(deserializing) { }
@@ -51,5 +37,5 @@
     public SymbolicExpressionTreeManipulator()
       : base() {
-      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree on which the operator should be applied."));
+      
     }
 
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeEncoding.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeEncoding.cs	(revision 12422)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeEncoding.cs	(revision 12422)
@@ -0,0 +1,368 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
+  [Item("SymbolicExpressionTreeEncoding", "Describes a symbolic expression tree encoding.")]
+  [StorableClass]
+  public sealed class SymbolicExpressionTreeEncoding : Encoding<ISymbolicExpressionTreeCreator> {
+    #region Encoding Parameters
+    [Storable]
+    private IFixedValueParameter<IntValue> treeLengthParameter;
+    public IFixedValueParameter<IntValue> TreeLengthParameter {
+      get { return treeLengthParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Tree length parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Tree length parameter value must not be null.");
+        if (treeLengthParameter == value) return;
+
+        if (treeLengthParameter != null)
+          Parameters.Remove(treeLengthParameter);
+
+        treeLengthParameter = value;
+        Parameters.Add(treeLengthParameter);
+        OnLengthParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IFixedValueParameter<IntValue> treeDepthParameter;
+    public IFixedValueParameter<IntValue> TreeDepthParameter {
+      get { return treeDepthParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Tree length parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Tree length parameter value must not be null.");
+        if (treeDepthParameter == value) return;
+
+        if (treeDepthParameter != null)
+          Parameters.Remove(treeDepthParameter);
+
+        treeDepthParameter = value;
+        Parameters.Add(treeDepthParameter);
+        OnDepthParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IValueParameter<ISymbolicExpressionGrammar> grammarParameter;
+    public IValueParameter<ISymbolicExpressionGrammar> GrammarParameter {
+      get { return grammarParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Grammar parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Grammar parameter value must not be null.");
+        if (grammarParameter == value) return;
+
+        if (grammarParameter != null)
+          Parameters.Remove(grammarParameter);
+
+        grammarParameter = value;
+        Parameters.Add(grammarParameter);
+        OnGrammarParameterChanged();
+      }
+    }
+
+
+    [Storable]
+    private IFixedValueParameter<IntValue> functionDefinitionsParameter;
+    public IFixedValueParameter<IntValue> FunctionDefinitionsParameter {
+      get { return functionDefinitionsParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Function definitions parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Function definitions parameter value must not be null.");
+        if (functionDefinitionsParameter == value) return;
+
+        if (functionDefinitionsParameter != null)
+          Parameters.Remove(functionDefinitionsParameter);
+
+        functionDefinitionsParameter = value;
+        Parameters.Add(functionDefinitionsParameter);
+        OnFunctionDefinitionsParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IFixedValueParameter<IntValue> functionArgumentsParameter;
+    public IFixedValueParameter<IntValue> FunctionArgumentsParameter {
+      get { return functionArgumentsParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Function arguments parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Function arguments parameter value must not be null.");
+        if (functionArgumentsParameter == value) return;
+
+        if (functionArgumentsParameter != null)
+          Parameters.Remove(functionArgumentsParameter);
+
+        functionArgumentsParameter = value;
+        Parameters.Add(functionArgumentsParameter);
+        OnFunctionArgumentsParameterChanged();
+      }
+    }
+    #endregion
+
+    #region Parameter properties
+    public int TreeLength {
+      get { return TreeLengthParameter.Value.Value; }
+      set { TreeLengthParameter.Value.Value = value; }
+    }
+
+    public int TreeDepth {
+      get { return TreeDepthParameter.Value.Value; }
+      set { TreeDepthParameter.Value.Value = value; }
+    }
+
+    public ISymbolicExpressionGrammar Grammar {
+      get { return GrammarParameter.Value; }
+      set { GrammarParameter.Value = value; }
+    }
+
+    public int FunctionDefinitions {
+      get { return FunctionDefinitionsParameter.Value.Value; }
+      set { FunctionDefinitionsParameter.Value.Value = value; }
+    }
+
+    public int FunctionArguments {
+      get { return FunctionArgumentsParameter.Value.Value; }
+      set { FunctionArgumentsParameter.Value.Value = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicExpressionTreeEncoding(bool deserializing) : base(deserializing) { }
+    public SymbolicExpressionTreeEncoding(ISymbolicExpressionGrammar grammar) : this("SymbolicExpressionTree", grammar, 50, 50) { }
+    public SymbolicExpressionTreeEncoding(ISymbolicExpressionGrammar grammar, int maximumLength, int maximumDepth) : this("SymbolicExpressionTree", grammar, maximumLength, maximumDepth) { }
+    public SymbolicExpressionTreeEncoding(string name, ISymbolicExpressionGrammar grammar, int maximumLength, int maximumDepth)
+      : base(name) {
+      treeLengthParameter = new FixedValueParameter<IntValue>("Maximum Tree Length", "Maximal length of the symbolic expression.", new IntValue(maximumLength));
+      treeDepthParameter = new FixedValueParameter<IntValue>("Maximum Tree Depth", "Maximal depth of the symbolic expression. The minimum depth needed for the algorithm is 3 because two levels are reserved for the ProgramRoot and the Start symbol.", new IntValue(maximumDepth));
+      grammarParameter = new ValueParameter<ISymbolicExpressionGrammar>("Grammar", "The grammar that should be used for symbolic expression tree.", grammar);
+      functionDefinitionsParameter = new FixedValueParameter<IntValue>("Function Definitions", "Maximal number of automatically defined functions", new IntValue(0));
+      functionArgumentsParameter = new FixedValueParameter<IntValue>("Function Arguments", "Maximal number of arguments of automatically defined functions.", new IntValue(0));
+
+      Parameters.Add(treeLengthParameter);
+      Parameters.Add(treeDepthParameter);
+      Parameters.Add(grammarParameter);
+      Parameters.Add(functionDefinitionsParameter);
+      Parameters.Add(functionArgumentsParameter);
+
+      SolutionCreator = new ProbabilisticTreeCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private SymbolicExpressionTreeEncoding(SymbolicExpressionTreeEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      treeLengthParameter = cloner.Clone(original.TreeLengthParameter);
+      treeDepthParameter = cloner.Clone(original.TreeDepthParameter);
+      grammarParameter = cloner.Clone(original.GrammarParameter);
+      functionDefinitionsParameter = cloner.Clone(original.FunctionDefinitionsParameter);
+      functionArgumentsParameter = cloner.Clone(original.FunctionArgumentsParameter);
+      RegisterParameterEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreeEncoding(this, cloner);
+    }
+
+    #region changed events
+    private void OnLengthParameterChanged() {
+      RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnDepthParameterChanged() {
+      RegisterDepthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnGrammarParameterChanged() {
+      RegisterGrammarParameterEvents();
+      FunctionArguments = Grammar.MaximumFunctionArguments;
+      FunctionDefinitions = Grammar.MaximumFunctionDefinitions;
+      ConfigureOperators(Operators);
+    }
+
+    private void OnFunctionDefinitionsParameterChanged() {
+      RegisterFunctionDefinitionsParameterEvents();
+      Grammar.MaximumFunctionDefinitions = FunctionDefinitions;
+    }
+
+    private void OnFunctionArgumentsParameterChanged() {
+      RegisterFunctionArgumentsParameterEvetns();
+      Grammar.MaximumFunctionArguments = FunctionArguments;
+    }
+
+    private void RegisterParameterEvents() {
+      RegisterLengthParameterEvents();
+      RegisterLengthParameterEvents();
+      RegisterGrammarParameterEvents();
+      RegisterFunctionDefinitionsParameterEvents();
+      RegisterFunctionArgumentsParameterEvetns();
+    }
+
+
+    private void RegisterLengthParameterEvents() { }
+    private void RegisterDepthParameterEvents() { }
+
+    private void RegisterGrammarParameterEvents() {
+      GrammarParameter.ValueChanged += (o, s) => {
+        FunctionArguments = Grammar.MaximumFunctionArguments;
+        FunctionDefinitions = Grammar.MaximumFunctionDefinitions;
+        ConfigureOperators(Operators);
+      };
+      GrammarParameter.Value.Changed += (o, s) => {
+        FunctionArguments = Grammar.MaximumFunctionArguments;
+        FunctionDefinitions = Grammar.MaximumFunctionDefinitions;
+        ConfigureOperators(Operators);
+      };
+    }
+
+    private void RegisterFunctionDefinitionsParameterEvents() {
+      FunctionDefinitionsParameter.Value.ValueChanged += (o, s) => Grammar.MaximumFunctionDefinitions = FunctionDefinitions;
+    }
+    private void RegisterFunctionArgumentsParameterEvetns() {
+      FunctionArgumentsParameter.Value.ValueChanged += (o, s) => Grammar.MaximumFunctionArguments = FunctionArguments;
+    }
+    #endregion
+
+    #region Operator discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static SymbolicExpressionTreeEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>
+      {
+        typeof(ISymbolicExpressionTreeOperator),
+        typeof(ISymbolicExpressionTreeCreator),
+        typeof(ISymbolicExpressionTreeCrossover),
+        typeof(ISymbolicExpressionTreeManipulator),
+        typeof(ISymbolicExpressionTreeArchitectureAlteringOperator),
+        typeof(ISymbolicExpressionTreeAnalyzer),
+      };
+    }
+
+    private void DiscoverOperators() {
+      var assembly = typeof(ISymbolicExpressionTreeOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        AddOperator(@operator);
+    }
+    #endregion
+
+    #region Specific operator wiring
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+      ConfigureTreeOperators(operators.OfType<ISymbolicExpressionTreeOperator>());
+      ConfigureSizeConstraintOperators(operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>());
+      ConfigureGrammarBaseOperators(operators.OfType<ISymbolicExpressionTreeGrammarBasedOperator>());
+      ConfigureArchitectureAlteringOperators(operators.OfType<ISymbolicExpressionTreeArchitectureAlteringOperator>());
+
+      ConfigureAnalyzers(operators.OfType<ISymbolicExpressionTreeAnalyzer>());
+      ConfigureCreators(operators.OfType<ISymbolicExpressionTreeCreator>());
+      ConfigureCrossovers(operators.OfType<ISymbolicExpressionTreeCrossover>());
+      ConfigureManipulators(operators.OfType<ISymbolicExpressionTreeManipulator>());
+    }
+
+    private void ConfigureTreeOperators(IEnumerable<ISymbolicExpressionTreeOperator> treeOperators) {
+      foreach (var treeOperator in treeOperators) {
+        treeOperator.SymbolicExpressionTreeParameter.ActualName = Name;
+        treeOperator.SymbolicExpressionTreeParameter.Hidden = true;
+      }
+    }
+
+    private void ConfigureSizeConstraintOperators(IEnumerable<ISymbolicExpressionTreeSizeConstraintOperator> sizeConstraintOperators) {
+      foreach (var sizeConstraintOperator in sizeConstraintOperators) {
+        sizeConstraintOperator.MaximumSymbolicExpressionTreeLengthParameter.ActualName = TreeLengthParameter.Name;
+        sizeConstraintOperator.MaximumSymbolicExpressionTreeLengthParameter.Hidden = true;
+        sizeConstraintOperator.MaximumSymbolicExpressionTreeDepthParameter.ActualName = TreeDepthParameter.Name;
+        sizeConstraintOperator.MaximumSymbolicExpressionTreeDepthParameter.Hidden = true;
+      }
+    }
+
+    private void ConfigureGrammarBaseOperators(IEnumerable<ISymbolicExpressionTreeGrammarBasedOperator> grammarBasedOperators) {
+      foreach (var grammarBasedOperator in grammarBasedOperators) {
+        grammarBasedOperator.SymbolicExpressionTreeGrammarParameter.ActualName = GrammarParameter.Name;
+        grammarBasedOperator.SymbolicExpressionTreeGrammarParameter.Hidden = true;
+      }
+    }
+
+    private void ConfigureArchitectureAlteringOperators(IEnumerable<ISymbolicExpressionTreeArchitectureAlteringOperator> architectureAlteringOperators) {
+      foreach (var architectureAlteringOperator in architectureAlteringOperators) {
+        architectureAlteringOperator.MaximumFunctionDefinitionsParameter.ActualName = FunctionDefinitionsParameter.Name;
+        architectureAlteringOperator.MaximumFunctionDefinitionsParameter.Hidden = true;
+        architectureAlteringOperator.MaximumFunctionArgumentsParameter.ActualName = FunctionArgumentsParameter.Name;
+        architectureAlteringOperator.MaximumFunctionArgumentsParameter.Hidden = true;
+      }
+
+    }
+
+    private void ConfigureAnalyzers(IEnumerable<ISymbolicExpressionTreeAnalyzer> analyzers) {
+      foreach (var analyzer in analyzers) {
+        analyzer.SymbolicExpressionTreeParameter.ActualName = Name;
+        analyzer.SymbolicExpressionTreeParameter.Hidden = true;
+      }
+      foreach (var analyzer in analyzers.OfType<SymbolicExpressionTreeLengthAnalyzer>()) {
+        analyzer.MaximumSymbolicExpressionTreeLengthParameter.ActualName = TreeLengthParameter.Name;
+        analyzer.MaximumSymbolicExpressionTreeLengthParameter.Hidden = true;
+      }
+    }
+
+    private void ConfigureCreators(IEnumerable<ISymbolicExpressionTreeCreator> creators) {
+      //Empty interface
+      foreach (var creator in creators) { }
+    }
+
+    private void ConfigureCrossovers(IEnumerable<ISymbolicExpressionTreeCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ParentsParameter.ActualName = Name;
+        crossover.ParentsParameter.Hidden = true;
+      }
+    }
+
+    private void ConfigureManipulators(IEnumerable<ISymbolicExpressionTreeManipulator> manipulators) {
+      //Empty interface
+      foreach (var manipulator in manipulators) { }
+    }
+    #endregion
+  }
+
+  public static class IndividualExtensionMethods {
+    public static ISymbolicExpressionTree SymbolicExpressionTree(this Individual individual) {
+      var encoding = individual.GetEncoding<SymbolicExpressionTreeEncoding>();
+      return individual.SymbolicExpressionTree(encoding.Name);
+    }
+
+    public static ISymbolicExpressionTree SymbolicExpressionTree(this Individual individual, string name) {
+      return (ISymbolicExpressionTree)individual[name];
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeOperator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeOperator.cs	(revision 12422)
@@ -22,5 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -36,4 +35,5 @@
   public abstract class SymbolicExpressionTreeOperator : InstrumentedOperator, IStochasticOperator, ISymbolicExpressionTreeOperator {
     private const string RandomParameterName = "Random";
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
 
     public override bool CanChangeName {
@@ -45,9 +45,6 @@
       get { return (LookupParameter<IRandom>)Parameters[RandomParameterName]; }
     }
-    #endregion
-
-    #region Properties
-    public IRandom Random {
-      get { return RandomParameter.ActualValue; }
+    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
     }
     #endregion
@@ -59,4 +56,14 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>(RandomParameterName, "The pseudo random number generator which should be used for symbolic expression tree operators."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree on which the operator should be applied."));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code, remove with 3.4
+      if (!Parameters.ContainsKey(SymbolicExpressionTreeParameterName))
+        Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree on which the operator should be applied."));
+      #endregion
     }
   }
Index: trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/SimpleSymbol.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/SimpleSymbol.cs	(revision 12422)
+++ trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/SimpleSymbol.cs	(revision 12422)
@@ -0,0 +1,70 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
+  [StorableClass]
+  [Item("SimpleSymbol", "Represents a symbol that is identified by its name.")]
+  [NonDiscoverableType]
+  public sealed class SimpleSymbol : Symbol {
+    [Storable]
+    private readonly int minimumArity;
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+
+    [Storable]
+    private readonly int maximumArity = byte.MaxValue;
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    [StorableConstructor]
+    private SimpleSymbol(bool deserializing) : base(deserializing) { }
+
+    private SimpleSymbol(SimpleSymbol original, Cloner cloner)
+      : base(original, cloner) {
+      minimumArity = original.minimumArity;
+      maximumArity = original.maximumArity;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SimpleSymbol(this, cloner);
+    }
+
+    public SimpleSymbol(string name, string description, int minimumArity, int maximumArity)
+      : base(name, description) {
+      this.minimumArity = minimumArity;
+      this.maximumArity = maximumArity;
+    }
+
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.4/ArtificialAntProblem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.4/ArtificialAntProblem.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.4/ArtificialAntProblem.cs	(revision 12422)
@@ -274,5 +274,5 @@
       foreach (ISymbolicExpressionTreeCrossover op in operators.OfType<ISymbolicExpressionTreeCrossover>()) {
         op.ParentsParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-        op.ChildParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
       }
       foreach (ISymbolicExpressionTreeManipulator op in operators.OfType<ISymbolicExpressionTreeManipulator>()) {
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPhenotypicDiversityAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPhenotypicDiversityAnalyzer.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPhenotypicDiversityAnalyzer.cs	(revision 12422)
@@ -35,5 +35,5 @@
   [StorableClass]
   public class SymbolicClassificationPhenotypicDiversityAnalyzer : PopulationSimilarityAnalyzer,
-    ISymbolicDataAnalysisBoundedOperator, ISymbolicDataAnalysisInterpreterOperator, ISymbolicExpressionTreeOperator {
+    ISymbolicDataAnalysisBoundedOperator, ISymbolicDataAnalysisInterpreterOperator, ISymbolicExpressionTreeAnalyzer {
     #region parameter names
     private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs	(revision 12422)
@@ -35,5 +35,5 @@
   [StorableClass]
   public class SymbolicRegressionPhenotypicDiversityAnalyzer : PopulationSimilarityAnalyzer,
-    ISymbolicDataAnalysisBoundedOperator, ISymbolicDataAnalysisInterpreterOperator, ISymbolicExpressionTreeOperator {
+    ISymbolicDataAnalysisBoundedOperator, ISymbolicDataAnalysisInterpreterOperator, ISymbolicExpressionTreeAnalyzer {
     #region parameter names
     private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/MultiSymbolicDataAnalysisExpressionCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/MultiSymbolicDataAnalysisExpressionCrossover.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/MultiSymbolicDataAnalysisExpressionCrossover.cs	(revision 12422)
@@ -35,8 +35,9 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [Item("MultiSymbolicDataAnalysisExpressionCrossover", "Randomly selects and applies one of its crossovers every time it is called.")]
+  [StorableClass]
   public class MultiSymbolicDataAnalysisExpressionCrossover<T> : StochasticMultiBranch<ISymbolicExpressionTreeCrossover>,
     ISymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData {
     private const string ParentsParameterName = "Parents";
-    private const string ChildParameterName = "Child";
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
     private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
     private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
@@ -62,6 +63,6 @@
       get { return (ScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[ParentsParameterName]; }
     }
-    public ILookupParameter<ISymbolicExpressionTree> ChildParameter {
-      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[ChildParameterName]; }
+    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
     }
     public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
@@ -99,5 +100,5 @@
       Parameters.Add(new ValueLookupParameter<IntRange>(SymbolicDataAnalysisEvaluationPartitionParameterName, "The start index of the dataset partition on which the symbolic data analysis solution should be evaluated."));
       Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(ParentsParameterName, "The parent symbolic expression trees which should be crossed."));
-      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(ChildParameterName, "The child symbolic expression tree resulting from the crossover."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The child symbolic expression tree resulting from the crossover."));
 
       EvaluatorParameter.Hidden = true;
@@ -111,4 +112,13 @@
 
       SelectedOperatorParameter.ActualName = "SelectedCrossoverOperator";
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code, remove with 3.4
+      if (!Parameters.ContainsKey(SymbolicExpressionTreeParameterName))
+        Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree on which the operator should be applied."));
+      #endregion
     }
 
@@ -155,5 +165,5 @@
     private void ParameterizeCrossovers() {
       foreach (ISymbolicExpressionTreeCrossover op in Operators) {
-        op.ChildParameter.ActualName = ChildParameter.Name;
+        op.SymbolicExpressionTreeParameter.ActualName = SymbolicExpressionTreeParameter.Name;
         op.ParentsParameter.ActualName = ParentsParameter.Name;
       }
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionContextAwareCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionContextAwareCrossover.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionContextAwareCrossover.cs	(revision 12422)
@@ -27,4 +27,5 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -68,5 +69,6 @@
           possibleChildren.Add(n);
       });
-      var selectedChild = possibleChildren.SelectRandom(random);
+
+      var selectedChild = possibleChildren.SampleRandom(random);
       var crossoverPoints = new List<CutPoint>();
       var qualities = new List<Tuple<CutPoint, double>>();
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs	(revision 12422)
@@ -29,4 +29,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -115,6 +116,5 @@
         throw new Exception("No crossover points available in the first parent");
 
-      var crossoverPoint0 = crossoverPoints0.SelectRandom(random);
-
+      var crossoverPoint0 = crossoverPoints0.SampleRandom(random);
       int level = parent0.Root.GetBranchLevel(crossoverPoint0.Child);
       int length = parent0.Root.GetLength() - crossoverPoint0.Child.GetLength();
@@ -126,5 +126,6 @@
                              select s).ToList();
       if (allowedBranches.Count == 0) return parent0;
-      var selectedBranch = allowedBranches.SelectRandom(random);
+
+      var selectedBranch = allowedBranches.SampleRandom(random);
       Swap(crossoverPoint0, selectedBranch);
       return parent0;
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDeterministicBestCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDeterministicBestCrossover.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDeterministicBestCrossover.cs	(revision 12422)
@@ -27,4 +27,5 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -67,5 +68,6 @@
           crossoverPoints0.Add(new CutPoint(n.Parent, n));
       });
-      CutPoint crossoverPoint0 = crossoverPoints0.SelectRandom(random);
+
+      CutPoint crossoverPoint0 = crossoverPoints0.SampleRandom(random);
       int level = parent0.Root.GetBranchLevel(crossoverPoint0.Child);
       int length = parent0.Root.GetLength() - crossoverPoint0.Child.GetLength();
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover.cs	(revision 12422)
@@ -27,4 +27,5 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -69,5 +70,6 @@
         }
       });
-      var crossoverPoint0 = crossoverPoints0.SelectRandom(random);
+
+      var crossoverPoint0 = crossoverPoints0.SampleRandom(random);
       int level = parent0.Root.GetBranchLevel(crossoverPoint0.Child);
       int length = parent0.Root.GetLength() - crossoverPoint0.Child.GetLength();
@@ -137,5 +139,7 @@
           weights[i] /= sum;
 
+#pragma warning disable 612, 618
         selectedBranch = allowedBranches.SelectRandom(weights, random);
+#pragma warning restore 612, 618
       }
       Swap(crossoverPoint0, selectedBranch);
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionSemanticSimilarityCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionSemanticSimilarityCrossover.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionSemanticSimilarityCrossover.cs	(revision 12422)
@@ -28,4 +28,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -81,5 +82,6 @@
           crossoverPoints0.Add(new CutPoint(n.Parent, n));
       });
-      var crossoverPoint0 = crossoverPoints0.SelectRandom(random);
+
+      var crossoverPoint0 = crossoverPoints0.SampleRandom(random);
       int level = parent0.Root.GetBranchLevel(crossoverPoint0.Child);
       int length = parent0.Root.GetLength() - crossoverPoint0.Child.GetLength();
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 12422)
@@ -321,5 +321,5 @@
       foreach (var op in operators.OfType<ISymbolicExpressionTreeCrossover>()) {
         op.ParentsParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-        op.ChildParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
       }
       foreach (var op in operators.OfType<ISymbolicExpressionTreeManipulator>()) {
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableConditionTreeNode.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableConditionTreeNode.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableConditionTreeNode.cs	(revision 12422)
@@ -74,5 +74,9 @@
       base.ResetLocalParameters(random);
       threshold = NormalDistributedRandom.NextDouble(random, Symbol.ThresholdInitializerMu, Symbol.ThresholdInitializerSigma);
+
+#pragma warning disable 612, 618
       variableName = Symbol.VariableNames.SelectRandom(random);
+#pragma warning restore 612, 618
+
       slope = NormalDistributedRandom.NextDouble(random, Symbol.SlopeInitializerMu, Symbol.SlopeInitializerSigma);
     }
@@ -82,5 +86,9 @@
       double x = NormalDistributedRandom.NextDouble(random, Symbol.ThresholdManipulatorMu, Symbol.ThresholdManipulatorSigma);
       threshold = threshold + x * shakingFactor;
+
+#pragma warning disable 612, 618
       variableName = Symbol.VariableNames.SelectRandom(random);
+#pragma warning restore 612, 618
+
       x = NormalDistributedRandom.NextDouble(random, Symbol.SlopeManipulatorMu, Symbol.SlopeManipulatorSigma);
       slope = slope + x * shakingFactor;
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableTreeNode.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableTreeNode.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableTreeNode.cs	(revision 12422)
@@ -61,5 +61,8 @@
       base.ResetLocalParameters(random);
       weight = NormalDistributedRandom.NextDouble(random, Symbol.WeightMu, Symbol.WeightSigma);
+
+#pragma warning disable 612, 618
       variableName = Symbol.VariableNames.SelectRandom(random);
+#pragma warning restore 612, 618
     }
 
@@ -70,9 +73,11 @@
         double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorMu, Symbol.WeightManipulatorSigma);
         weight = weight + x * shakingFactor;
-      } else {        
+      } else {
         double x = NormalDistributedRandom.NextDouble(random, 1.0, Symbol.MultiplicativeWeightManipulatorSigma);
         weight = weight * x;
       }
+#pragma warning disable 612, 618
       variableName = Symbol.VariableNames.SelectRandom(random);
+#pragma warning restore 612, 618
     }
 
Index: trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.3/ArtificialAnt/GEArtificialAntEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.3/ArtificialAnt/GEArtificialAntEvaluator.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.3/ArtificialAnt/GEArtificialAntEvaluator.cs	(revision 12422)
@@ -49,6 +49,6 @@
     }
     // phenotype:
-    public ILookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
-      get { return (ILookupParameter<SymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
+    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
     }
     public ILookupParameter<BoolMatrix> WorldParameter {
@@ -84,5 +84,5 @@
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the evaluated artificial ant solution."));
       Parameters.Add(new LookupParameter<IntegerVector>("IntegerVector", "The artificial ant solution encoded as an integer vector genome."));
-      Parameters.Add(new LookupParameter<SymbolicExpressionTree>("SymbolicExpressionTree", "The artificial ant solution encoded as a symbolic expression tree that should be evaluated"));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>("SymbolicExpressionTree", "The artificial ant solution encoded as a symbolic expression tree that should be evaluated"));
       Parameters.Add(new LookupParameter<BoolMatrix>("World", "The world for the artificial ant with scattered food items."));
       Parameters.Add(new LookupParameter<IntValue>("MaxTimeSteps", "The maximal number of time steps that the artificial ant should be simulated."));
@@ -93,4 +93,19 @@
       Parameters.Add(new LookupParameter<IntMatrix>("Bounds", "The integer number range in which the single genomes of a genotype are created."));
       Parameters.Add(new LookupParameter<IntValue>("MaximumExpressionLength", "Maximal length of the expression to control the artificial ant (genotype length)."));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code, remove with 3.4
+
+      if (Parameters.ContainsKey("SymbolicExpressionTree") &&
+          Parameters["SymbolicExpressionTree"] is ILookupParameter<SymbolicExpressionTree>) {
+        Parameters.Remove("SymbolicExpressionTree");
+        Parameters.Add(new LookupParameter<ISymbolicExpressionTree>("SymbolicExpressionTree", "The artificial ant solution encoded as a symbolic expression tree that should be evaluated"));
+      }
+
+      #endregion
+
     }
 
Index: trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.3/Mappers/GenotypeToPhenotypeMapper.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.3/Mappers/GenotypeToPhenotypeMapper.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.3/Mappers/GenotypeToPhenotypeMapper.cs	(revision 12422)
@@ -31,4 +31,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.GrammaticalEvolution.Mappers;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.GrammaticalEvolution {
@@ -68,5 +69,5 @@
       if (!possibleSymbolsList.Any()) return null;
 
-      var newNode = possibleSymbolsList.SelectRandom(random).CreateTreeNode();
+      var newNode = possibleSymbolsList.SampleRandom(random).CreateTreeNode();
       if (newNode.HasLocalParameters) newNode.ResetLocalParameters(random);
       return newNode;
Index: trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.3/Mappers/RandomMapper.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.3/Mappers/RandomMapper.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.3/Mappers/RandomMapper.cs	(revision 12422)
@@ -29,4 +29,5 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.GrammaticalEvolution {
@@ -102,5 +103,5 @@
         } else {
           // similar to PIGEMapper, but here the current node is determined randomly ...
-          ISymbolicExpressionTreeNode current = nonTerminals.SelectRandom(random);
+          ISymbolicExpressionTreeNode current = nonTerminals.SampleRandom(random);
           nonTerminals.Remove(current);
 
Index: trunk/sources/HeuristicLab.Problems.LawnMower/3.3/Problem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.LawnMower/3.3/Problem.cs	(revision 12401)
+++ trunk/sources/HeuristicLab.Problems.LawnMower/3.3/Problem.cs	(revision 12422)
@@ -185,5 +185,5 @@
       foreach (var op in operators.OfType<ISymbolicExpressionTreeCrossover>()) {
         op.ParentsParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-        op.ChildParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
       }
       foreach (var op in operators.OfType<ISymbolicExpressionTreeManipulator>()) {
