Changeset 2210 for branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3

Timestamp:

07/29/09 18:28:45 (15 years ago)

Author:

gkronber

Message:

GP Refactoring #713

• introduced a plugin for GP interfaces
• created a new interface IGeneticProgrammingModel which represents GP models in HL scopes instead of IFunctionTree
• changed interfaces IFunction and IFunctionTree
• moved some files to new directories (general housekeeping)
• changed all GP operators and engines to work with IGeneticProgrammingModels
• removed parameters TreeSize and TreeHeight in all GP operators
• changed parameter OperatorLibrary to FunctionLibrary in all GP operators

Location:

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3

Files:

• BaseClasses (added)
• BaseClasses/BakedFunctionTree.cs (moved) (moved from branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/BakedFunctionTree.cs)
• BaseClasses/BinaryFunction.cs (copied) (copied from branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/BinaryFunction.cs) (1 diff)
• BaseClasses/FunctionBase.cs (moved) (moved from branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/FunctionBase.cs) (2 diffs)
• BaseClasses/FunctionTreeBase.cs (added)
• BaseClasses/Terminal.cs (copied) (copied from branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/Terminal.cs) (1 diff)
• BaseClasses/UnaryFunction.cs (copied) (copied from branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/UnaryFunction.cs) (1 diff)
• DefaultFunctionTreeNameGenerator.cs (modified) (1 diff)
• FunView.cs (modified) (1 diff)
• FunctionGroup.cs (deleted)
• FunctionLibrary.cs (modified) (1 diff)
• FunctionLibraryEditor.cs (modified) (1 diff)
• FunctionTreeView.cs (modified) (3 diffs)
• GeneticProgrammingModel.cs (added)
• HeuristicLab.GP-3.3.csproj (modified) (5 diffs)
• HeuristicLabGPPlugin.cs (modified) (1 diff)
• Initialization (added)
• Initialization/ProbabilisticTreeCreator.cs (moved) (moved from branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/ProbabilisticTreeCreator.cs) (3 diffs)
• Initialization/RampedTreeCreator.cs (moved) (moved from branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/RampedTreeCreator.cs) (4 diffs)
• Logging/TreeArityAnalyser.cs (modified) (3 diffs)
• Manipulation/ChangeNodeTypeManipulation.cs (modified) (9 diffs)
• Manipulation/CutOutNodeManipulation.cs (modified) (4 diffs)
• Manipulation/DeleteSubTreeManipulation.cs (modified) (4 diffs)
• Manipulation/FullTreeShaker.cs (modified) (2 diffs)
• Manipulation/GPManipulatorBase.cs (added)
• Manipulation/OnePointShaker.cs (modified) (3 diffs)
• Manipulation/SubstituteSubTreeManipulation.cs (modified) (6 diffs)
• Recombination/GPCrossoverBase.cs (modified) (4 diffs)
• Recombination/LangdonHomologousCrossOver.cs (modified) (1 diff)
• Recombination/OnePointCrossOver.cs (modified) (3 diffs)
• Recombination/SizeConstrictedGPCrossoverBase.cs (modified) (2 diffs)
• Recombination/SizeFairCrossOver.cs (modified) (4 diffs)
• Recombination/StandardCrossOver.cs (modified) (3 diffs)
• Recombination/UniformCrossover.cs (modified) (1 diff)
• TreeGardener.cs (modified) (16 diffs)

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/BaseClasses/BinaryFunction.cs

@@ -26 +26 @@
 using HeuristicLab.Constraints;
 
-namespace HeuristicLab.GP.StructureIdentification {
+namespace HeuristicLab.GP {
   public abstract class BinaryFunction : FunctionBase {
     public BinaryFunction()

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/BaseClasses/FunctionBase.cs

@@ -28 +28 @@
 using HeuristicLab.Constraints;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -107 +108 @@
 
     public virtual IFunctionTree GetTreeNode() {
-      return new BakedFunctionTree(this);
-    }
-
+      return new FunctionTreeBase(this);
+    }
 
     //private List<IConstraint> constraints = new List<IConstraint>();

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/BaseClasses/Terminal.cs

@@ -26 +26 @@
 using HeuristicLab.Constraints;
 
-namespace HeuristicLab.GP.StructureIdentification {
+namespace HeuristicLab.GP {
   public abstract class Terminal : FunctionBase {
     public Terminal()

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/BaseClasses/UnaryFunction.cs

@@ -26 +26 @@
 using HeuristicLab.Constraints;
 
-namespace HeuristicLab.GP.StructureIdentification {
+namespace HeuristicLab.GP {
   public abstract class UnaryFunction : FunctionBase {
     public UnaryFunction()

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/DefaultFunctionTreeNameGenerator.cs

@@ -24 +24 @@
 using System.Text;
 using HeuristicLab.Core;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/FunView.cs

@@ -8 +8 @@
 using System.Windows.Forms;
 using HeuristicLab.Core;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/FunctionLibrary.cs

@@ -28 +28 @@
 using HeuristicLab.Data;
 using HeuristicLab.Constraints;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/FunctionLibraryEditor.cs

@@ -33 +33 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Random;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/FunctionTreeView.cs

@@ -31 +31 @@
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Data;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -136 +137 @@
       if (funTreeView.SelectedNode != null && funTreeView.SelectedNode.Tag != null) {
         IFunctionTree selectedBranch = (IFunctionTree)funTreeView.SelectedNode.Tag;
-        UpdateVariablesList(selectedBranch);
+//      UpdateVariablesList(selectedBranch);
         templateTextBox.Text = nameGenerator.GetName(selectedBranch);
         this.selectedBranch = selectedBranch;
@@ -143 +144 @@
     }
 
-    private void UpdateVariablesList(IFunctionTree functionTree) {
-      foreach (IVariable variable in functionTree.LocalVariables) {
-        variablesListBox.Items.Add(variable.Name);
-      }
-    }
+    //private void UpdateVariablesList(IFunctionTree functionTree) {
+    //  foreach (IVariable variable in functionTree.LocalVariables) {
+    //    variablesListBox.Items.Add(variable.Name);
+    //  }
+    //}
 
     private void variablesListBox_SelectedIndexChanged(object sender, EventArgs e) {
-      // in case we had an event-handler registered for a different variable => unregister the event-handler
-      if (selectedVariable != null) {
-        selectedVariable.Value.Changed -= new EventHandler(selectedVariable_ValueChanged);
-      }
-      if (variablesListBox.SelectedItem != null) {
-        string selectedVariableName = (string)variablesListBox.SelectedItem;
-        selectedVariable = selectedBranch.GetLocalVariable(selectedVariableName);
-        variablesSplitContainer.Panel2.Controls.Clear();
-        Control editor = (Control)selectedVariable.CreateView();
-        variablesSplitContainer.Panel2.Controls.Add(editor);
-        editor.Dock = DockStyle.Fill;
-        // register an event handler that updates the treenode when the value of the variable is changed by the user
-        selectedVariable.Value.Changed += new EventHandler(selectedVariable_ValueChanged);
-      } else {
-        variablesSplitContainer.Panel2.Controls.Clear();
-      }
+      //// in case we had an event-handler registered for a different variable => unregister the event-handler
+      //if (selectedVariable != null) {
+      //  selectedVariable.Value.Changed -= new EventHandler(selectedVariable_ValueChanged);
+      //}
+      //if (variablesListBox.SelectedItem != null) {
+      //  string selectedVariableName = (string)variablesListBox.SelectedItem;
+      //  selectedVariable = selectedBranch.GetLocalVariable(selectedVariableName);
+      //  variablesSplitContainer.Panel2.Controls.Clear();
+      //  Control editor = (Control)selectedVariable.CreateView();
+      //  variablesSplitContainer.Panel2.Controls.Add(editor);
+      //  editor.Dock = DockStyle.Fill;
+      //  // register an event handler that updates the treenode when the value of the variable is changed by the user
+      //  selectedVariable.Value.Changed += new EventHandler(selectedVariable_ValueChanged);
+      //} else {
+      //  variablesSplitContainer.Panel2.Controls.Clear();
+      //}
     }
 

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/HeuristicLab.GP-3.3.csproj

@@ -82 +82 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="BakedFunctionTree.cs" />
+    <Compile Include="BaseClasses\BinaryFunction.cs" />
+    <Compile Include="BaseClasses\FunctionBase.cs" />
+    <Compile Include="BaseClasses\FunctionTreeBase.cs" />
+    <Compile Include="BaseClasses\Terminal.cs" />
+    <Compile Include="BaseClasses\UnaryFunction.cs" />
     <Compile Include="FunctionLibrary.cs" />
     <Compile Include="FunctionLibraryEditor.cs">
@@ -102 +106 @@
       <DependentUpon>FunView.cs</DependentUpon>
     </Compile>
+    <Compile Include="GeneticProgrammingModel.cs" />
+    <Compile Include="Initialization\ProbabilisticTreeCreator.cs" />
+    <Compile Include="Initialization\RampedTreeCreator.cs" />
+    <Compile Include="Manipulation\GPManipulatorBase.cs" />
     <Compile Include="TrainingWindowSlider.cs" />
     <Compile Include="DefaultFunctionTreeNameGenerator.cs" />
@@ -111 +119 @@
     <Compile Include="Recombination\UniformCrossover.cs" />
     <Compile Include="UnknownFunctionException.cs" />
-    <Compile Include="IFunctionTreeNameGenerator.cs" />
-    <Compile Include="IFunctionTreeExporter.cs" />
-    <Compile Include="FunctionBase.cs" />
     <Compile Include="HeuristicLabGPPlugin.cs" />
-    <Compile Include="IFunction.cs" />
-    <Compile Include="IFunctionTree.cs" />
     <Compile Include="Manipulation\ChangeNodeTypeManipulation.cs" />
     <Compile Include="Manipulation\CutOutNodeManipulation.cs" />
@@ -123 +126 @@
     <Compile Include="Manipulation\OnePointShaker.cs" />
     <Compile Include="Manipulation\SubstituteSubTreeManipulation.cs" />
-    <Compile Include="ProbabilisticTreeCreator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="RampedTreeCreator.cs" />
     <Compile Include="Recombination\LangdonHomologousCrossOver.cs" />
     <Compile Include="Recombination\OnePointCrossOver.cs" />
@@ -148 +149 @@
       <Project>{F5614C53-153C-4A37-A608-121E1C087F07}</Project>
       <Name>HeuristicLab.Evolutionary-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.GP.Interfaces\3.3\HeuristicLab.GP.Interfaces-3.3.csproj">
+      <Project>{924B6BEA-9A99-40FE-9334-5C01E8D540EC}</Project>
+      <Name>HeuristicLab.GP.Interfaces-3.3</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Operators\3.2\HeuristicLab.Operators-3.2.csproj">

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/HeuristicLabGPPlugin.cs

@@ -28 +28 @@
   [ClassInfo(Name = "HeuristicLab.GP-3.3")]
   [PluginFile(Filename = "HeuristicLab.GP-3.3.dll", Filetype = PluginFileType.Assembly)]
+  [Dependency(Dependency = "HeuristicLab.GP.Interfaces-3.3")]
   [Dependency(Dependency = "HeuristicLab.Constraints-3.2")]
   [Dependency(Dependency = "HeuristicLab.Core-3.2")]

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Initialization/ProbabilisticTreeCreator.cs

@@ -27 +27 @@
 using HeuristicLab.Random;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
+using System.Collections.Generic;
 
 namespace HeuristicLab.GP {
@@ -39 +41 @@
       : base() {
       AddVariableInfo(new VariableInfo("Random", "Uniform random number generator", typeof(MersenneTwister), VariableKind.In));
-      AddVariableInfo(new VariableInfo("OperatorLibrary", "The operator library containing all available operators", typeof(FunctionLibrary), VariableKind.In));
+      AddVariableInfo(new VariableInfo("FunctionLibrary", "The function library containing all available functions", typeof(FunctionLibrary), VariableKind.In));
       AddVariableInfo(new VariableInfo("MinTreeSize", "The minimal allowed size of the tree", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("MaxTreeSize", "The maximal allowed size of the tree", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("MaxTreeHeight", "The maximal allowed height of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The created tree", typeof(IFunctionTree), VariableKind.New | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeSize", "The size (number of nodes) of the tree", typeof(IntData), VariableKind.New | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeHeight", "The height of the tree", typeof(IntData), VariableKind.New | VariableKind.Out));
+      AddVariableInfo(new VariableInfo("FunctionTree", "The created tree", typeof(IGeneticProgrammingModel), VariableKind.New | VariableKind.Out));
     }
 
     public override IOperation Apply(IScope scope) {
       IRandom random = GetVariableValue<IRandom>("Random", scope, true);
-      FunctionLibrary opLibrary = GetVariableValue<FunctionLibrary>("OperatorLibrary", scope, true);
+      FunctionLibrary funLibrary = GetVariableValue<FunctionLibrary>("FunctionLibrary", scope, true);
       int minTreeSize = GetVariableValue<IntData>("MinTreeSize", scope, true).Data;
       int maxTreeSize = GetVariableValue<IntData>("MaxTreeSize", scope, true).Data;
       int maxTreeHeight = GetVariableValue<IntData>("MaxTreeHeight", scope, true).Data;
 
-      TreeGardener gardener = new TreeGardener(random, opLibrary);
-
       int treeSize = random.Next(minTreeSize, maxTreeSize + 1);
-
       IFunctionTree root;
-      int actualTreeSize;
-      int actualTreeHeight;
       int tries = 0;
+      TreeGardener gardener = new TreeGardener(random, funLibrary);
       do {
-        root = gardener.PTC2(random, treeSize, maxTreeHeight);
-        actualTreeSize = root.Size;
-        actualTreeHeight = root.Height;
+        root = gardener.PTC2(treeSize, maxTreeHeight);
         if (tries++ >= MAX_TRIES) {
           // try a different size
@@ -72 +66 @@
           tries = 0;
         }
-      } while (actualTreeSize > maxTreeSize || actualTreeHeight > maxTreeHeight);
+      } while (root.GetSize() > maxTreeSize || root.GetHeight() > maxTreeHeight);
 
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("FunctionTree"), root));
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TreeSize"), new IntData(actualTreeSize)));
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TreeHeight"), new IntData(actualTreeHeight)));
+      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("FunctionTree"), new GeneticProgrammingModel(root)));
+      return TreeGardener.CreateInitializationOperation(TreeGardener.GetAllSubTrees(root), scope);
+    }
 
-      return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(root), scope);
-    }
-  }
+ }
 }

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Initialization/RampedTreeCreator.cs

@@ -27 +27 @@
 using HeuristicLab.Random;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -37 +38 @@
       : base() {
       AddVariableInfo(new VariableInfo("Random", "Uniform random number generator", typeof(MersenneTwister), VariableKind.In));
-      AddVariableInfo(new VariableInfo("OperatorLibrary", "The operator library containing all available operators", typeof(FunctionLibrary), VariableKind.In));
+      AddVariableInfo(new VariableInfo("FunctionLibrary", "The function library containing all available functions", typeof(FunctionLibrary), VariableKind.In));
       AddVariableInfo(new VariableInfo("MinTreeHeight", "The minimal allowed height of the tree", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("MaxTreeHeight", "The maximal allowed height of the tree", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("BalancedTreesRate", "Determines how many trees should be balanced", typeof(DoubleData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The created tree", typeof(IFunctionTree), VariableKind.New | VariableKind.Out));
+      AddVariableInfo(new VariableInfo("FunctionTree", "The created tree", typeof(IGeneticProgrammingModel), VariableKind.New | VariableKind.Out));
       AddVariableInfo(new VariableInfo("TreeSize", "The size (number of nodes) of the tree", typeof(IntData), VariableKind.New | VariableKind.Out));
       AddVariableInfo(new VariableInfo("TreeHeight", "The height of the tree", typeof(IntData), VariableKind.New | VariableKind.Out));
@@ -48 +49 @@
     public override IOperation Apply(IScope scope) {
       IRandom random = GetVariableValue<IRandom>("Random", scope, true);
-      FunctionLibrary opLibrary = GetVariableValue<FunctionLibrary>("OperatorLibrary", scope, true);
+      FunctionLibrary opLibrary = GetVariableValue<FunctionLibrary>("FunctionLibrary", scope, true);
       int minTreeHeight = GetVariableValue<IntData>("MinTreeHeight", scope, true).Data;
       int maxTreeHeight = GetVariableValue<IntData>("MaxTreeHeight", scope, true).Data;
@@ -63 +64 @@
       }
 
-      int actualTreeSize = root.Size;
-      int actualTreeHeight = root.Height;
+      Debug.Assert(gardener.IsValidTree(root) && root.GetHeight() <= maxTreeHeight);
 
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("FunctionTree"), root));
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TreeSize"), new IntData(actualTreeSize)));
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TreeHeight"), new IntData(actualTreeHeight)));
-
-      Debug.Assert(gardener.IsValidTree(root) && actualTreeHeight <= maxTreeHeight);
-
-      return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(root), scope);
+      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("FunctionTree"), new GeneticProgrammingModel(root)));
+      return TreeGardener.CreateInitializationOperation(TreeGardener.GetAllSubTrees(root), scope);
     }
   }

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Logging/TreeArityAnalyser.cs

@@ -30 +30 @@
 using HeuristicLab.Constraints;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -43 +44 @@
     public TreeArityAnalyser()
       : base() {
-      AddVariableInfo(new VariableInfo("FunctionTree", "The tree to mutate", typeof(IFunctionTree), VariableKind.In));
+      AddVariableInfo(new VariableInfo("FunctionTree", "The tree to analyse", typeof(IGeneticProgrammingModel), VariableKind.In));
       AddVariableInfo(new VariableInfo("Histogram", "The histogram of arities over all functions in all functiontrees", typeof(ItemList<ItemList<IntData>>), VariableKind.New | VariableKind.Out));
     }
@@ -69 +70 @@
 
     private ItemList<ItemList<IntData>> GetArityHistogram(IScope subScope) {
-      IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", subScope, false);
+      IGeneticProgrammingModel gpModel = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", subScope, false);
       List<int> arities = new List<int>();
-      Arities(tree, arities);
+      Arities(gpModel.FunctionTree, arities);
       var histogram = arities.GroupBy(x => x, (g, xs) => new { Group = g, Count = xs.Count() }).OrderBy(g=>g.Group); // count number of distinct arities
       ItemList<ItemList<IntData>> result = new ItemList<ItemList<IntData>>();

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Manipulation/ChangeNodeTypeManipulation.cs

@@ -30 +30 @@
 using HeuristicLab.Constraints;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
-  public class ChangeNodeTypeManipulation : OperatorBase {
+  public class ChangeNodeTypeManipulation : GPManipulatorBase {
 
     public override string Description {
@@ -44 +45 @@
     public ChangeNodeTypeManipulation()
       : base() {
-      AddVariableInfo(new VariableInfo("Random", "Uniform random number generator", typeof(MersenneTwister), VariableKind.In));
-      AddVariableInfo(new VariableInfo("OperatorLibrary", "The operator library containing all available operators", typeof(FunctionLibrary), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MaxTreeHeight", "The maximal allowed height of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MaxTreeSize", "The maximal allowed size (number of nodes) of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The tree to mutate", typeof(IFunctionTree), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeSize", "The size (number of nodes) of the tree", typeof(IntData), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeHeight", "The height of the tree", typeof(IntData), VariableKind.In | VariableKind.Out));
     }
 
-
-    public override IOperation Apply(IScope scope) {
-      IFunctionTree root = GetVariableValue<IFunctionTree>("FunctionTree", scope, false);
-      MersenneTwister random = GetVariableValue<MersenneTwister>("Random", scope, true);
-      FunctionLibrary library = GetVariableValue<FunctionLibrary>("OperatorLibrary", scope, true);
-      IntData treeSize = GetVariableValue<IntData>("TreeSize", scope, false);
-      IntData treeHeight = GetVariableValue<IntData>("TreeHeight", scope, false);
-      int maxTreeSize = GetVariableValue<IntData>("MaxTreeSize", scope, true).Data;
-      int maxTreeHeight = GetVariableValue<IntData>("MaxTreeHeight", scope, true).Data;
+    internal override IOperation Manipulate(MersenneTwister random, IGeneticProgrammingModel gpModel, FunctionLibrary library, int maxTreeSize, int maxTreeHeight, IScope scope) {
       TreeGardener gardener = new TreeGardener(random, library);
-      IFunctionTree parent = gardener.GetRandomParentNode(root);
+      IFunctionTree parent = gardener.GetRandomParentNode(gpModel.FunctionTree);
       IFunctionTree selectedChild;
       int selectedChildIndex;
-      if(parent == null) {
+      if (parent == null) {
         selectedChildIndex = 0;
-        selectedChild = root;
+        selectedChild = gpModel.FunctionTree;
       } else {
         selectedChildIndex = random.Next(parent.SubTrees.Count);
@@ -74 +60 @@
       }
 
-      if(selectedChild.SubTrees.Count == 0) {
+      if (selectedChild.SubTrees.Count == 0) {
         IFunctionTree newTerminal = ChangeTerminalType(parent, selectedChild, selectedChildIndex, gardener, random);
-        if(parent == null) {
+        if (parent == null) {
           // no parent means the new child is the initial operator
-          // and we have to update the value in the variable
-          scope.GetVariable(scope.TranslateName("FunctionTree")).Value = newTerminal;
+          gpModel.FunctionTree = newTerminal;
         } else {
           parent.RemoveSubTree(selectedChildIndex);
@@ -85 +70 @@
           // updating the variable is not necessary because it stays the same
         }
-        Debug.Assert(gardener.IsValidTree(root));
+        Debug.Assert(gardener.IsValidTree(gpModel.FunctionTree));
         // size and height stays the same when changing a terminal so no need to update the variables
         // schedule an operation to initialize the new terminal
-        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newTerminal), scope);
+        return TreeGardener.CreateInitializationOperation(TreeGardener.GetAllSubTrees(newTerminal), scope);
       } else {
         List<IFunctionTree> uninitializedBranches;
@@ -95 +80 @@
         // calculate the height and size difference and 
         // check if the size of the new tree is still in the allowed bounds
-        int oldChildSize = selectedChild.Size;
-        int oldChildHeight = selectedChild.Height;
-        int newChildSize = newFunctionTree.Size;
-        int newChildHeight = newFunctionTree.Height;
-        if((treeHeight.Data - oldChildHeight) + newChildHeight > maxTreeHeight ||
-          (treeSize.Data - oldChildSize) + newChildSize > maxTreeSize) {
+        int oldChildSize = selectedChild.GetSize();
+        int oldChildHeight = selectedChild.GetHeight();
+        int newChildSize = newFunctionTree.GetSize();
+        int newChildHeight = newFunctionTree.GetHeight();
+        if ((gpModel.Height - oldChildHeight) + newChildHeight > maxTreeHeight ||
+          (gpModel.Size - oldChildSize) + newChildSize > maxTreeSize) {
           // if size-constraints are violated don't change anything
           return null;
         }
-        if(parent == null) {
+        if (parent == null) {
           // no parent means the new function is the initial operator
-          // and we have to update the value in the variable
-          scope.GetVariable(scope.TranslateName("FunctionTree")).Value = newFunctionTree;
-          root = newFunctionTree;
+          gpModel.FunctionTree = newFunctionTree;
         } else {
           // remove the old child
@@ -116 +99 @@
         }
         // update size and height
-        treeSize.Data = (treeSize.Data - oldChildSize) + newChildSize;
-        treeHeight.Data = root.Height; // must recalculate height because we can't know wether the manipulated branch was the deepest branch
+        gpModel.Size = gpModel.Size - oldChildSize + newChildSize;
+        gpModel.Height = gpModel.FunctionTree.GetHeight(); // must recalculate height because we can't know wether the manipulated branch was the deepest branch
         // check if whole tree is ok
-        Debug.Assert(gardener.IsValidTree(root));
+        Debug.Assert(gardener.IsValidTree(gpModel.FunctionTree));
         // return a composite operation that initializes all created sub-trees
-        return gardener.CreateInitializationOperation(uninitializedBranches, scope);
+        return TreeGardener.CreateInitializationOperation(uninitializedBranches, scope);
       }
     }
-  
 
     private IFunctionTree ChangeTerminalType(IFunctionTree parent, IFunctionTree child, int childIndex, TreeGardener gardener, MersenneTwister random) {
@@ -133 +115 @@
         allowedTerminals = new List<IFunction>();
         var allAllowedChildren = gardener.GetAllowedSubFunctions(parent.Function, childIndex);
-        foreach(IFunction c in allAllowedChildren) {
-          if(gardener.IsTerminal(c)) allowedTerminals.Add(c);
+        foreach (IFunction c in allAllowedChildren) {
+          if (TreeGardener.IsTerminal(c)) allowedTerminals.Add(c);
         }
       }
@@ -159 +141 @@
       if (actualArity > maxArity)
         actualArity = maxArity;
-      if(actualArity < minArity)
+      if (actualArity < minArity)
         actualArity = minArity;
       // create a list that holds old sub-trees that we can reuse in the new tree
@@ -181 +163 @@
           // no existing matching tree found => create a new tree of minimal size
           IFunctionTree freshTree = gardener.CreateRandomTree(allowedSubFunctions, 1, 1);
-          freshSubTrees.AddRange(gardener.GetAllSubTrees(freshTree));
+          freshSubTrees.AddRange(TreeGardener.GetAllSubTrees(freshTree));
           newTree.InsertSubTree(i, freshTree);
         }

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Manipulation/CutOutNodeManipulation.cs

@@ -28 +28 @@
 using System;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
-  public class CutOutNodeManipulation : OperatorBase {
+  public class CutOutNodeManipulation : GPManipulatorBase {
     public override string Description {
       get {
@@ -49 +50 @@
     public CutOutNodeManipulation()
       : base() {
-      AddVariableInfo(new VariableInfo("Random", "Uniform random number generator", typeof(MersenneTwister), VariableKind.In));
-      AddVariableInfo(new VariableInfo("OperatorLibrary", "The operator library containing all available operators", typeof(FunctionLibrary), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MaxTreeHeight", "The maximal allowed height of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MaxTreeSize", "The maximal allowed size (number of nodes) of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The tree to mutate", typeof(IFunctionTree), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeSize", "The size (number of nodes) of the tree", typeof(IntData), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeHeight", "The height of the tree", typeof(IntData), VariableKind.In | VariableKind.Out));
     }
 
 
-    public override IOperation Apply(IScope scope) {
-      IFunctionTree root = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
-      MersenneTwister random = GetVariableValue<MersenneTwister>("Random", scope, true);
-      FunctionLibrary library = GetVariableValue<FunctionLibrary>("OperatorLibrary", scope, true);
-      int maxTreeHeight = GetVariableValue<IntData>("MaxTreeHeight", scope, true).Data;
-      int maxTreeSize = GetVariableValue<IntData>("MaxTreeSize", scope, true).Data;
+    internal override IOperation Manipulate(MersenneTwister random, IGeneticProgrammingModel gpModel, FunctionLibrary library, int maxTreeSize, int maxTreeHeight, IScope scope) {
       TreeGardener gardener = new TreeGardener(random, library);
-      IFunctionTree parent = gardener.GetRandomParentNode(root);
+      IFunctionTree parent = gardener.GetRandomParentNode(gpModel.FunctionTree);
       // parent == null means we should cut out the root node
       // => return a random sub-tree of the root
       if (parent == null) {
         // when there are sub-trees then replace the old tree with a random sub-tree
-        if (root.SubTrees.Count > 0) {
-          root = root.SubTrees[random.Next(root.SubTrees.Count)];
-          GetVariableValue<IntData>("TreeSize", scope, true).Data = root.Size;
-          GetVariableValue<IntData>("TreeHeight", scope, true).Data = root.Height;
-          // update the variable
-          scope.GetVariable(scope.TranslateName("FunctionTree")).Value = root;
-          Debug.Assert(gardener.IsValidTree(root));
+        if (gpModel.FunctionTree.SubTrees.Count > 0) {
+          gpModel.FunctionTree = gpModel.FunctionTree.SubTrees[random.Next(gpModel.FunctionTree.SubTrees.Count)];
+          Debug.Assert(gardener.IsValidTree(gpModel.FunctionTree));
           // we reused a sub-tree so we don't have to schedule initialization operations
           return null;
         } else {
           // we want to cut the root node and there are no sub-trees => create a new random terminal
-          IFunctionTree newTree;
-          newTree = gardener.CreateRandomTree(gardener.Terminals, 1, 1);
-          GetVariableValue<IntData>("TreeSize", scope, true).Data = newTree.Size;
-          GetVariableValue<IntData>("TreeHeight", scope, true).Data = newTree.Height;
-          // update the variable
-          scope.GetVariable(scope.TranslateName("FunctionTree")).Value = newTree;
-          Debug.Assert(gardener.IsValidTree(newTree));
+          gpModel.FunctionTree = gardener.CreateRandomTree(gardener.Terminals, 1, 1);
+          Debug.Assert(gardener.IsValidTree(gpModel.FunctionTree));
+
           // schedule an operation to initialize the whole tree
-          return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newTree), scope);
+          return TreeGardener.CreateInitializationOperation(TreeGardener.GetAllSubTrees(gpModel.FunctionTree), scope);
         }
       }
+
       // select a child to cut away
       int childIndex = random.Next(parent.SubTrees.Count);
@@ -101 +83 @@
       if (possibleChilds.Length > 0) {
         // replace child with a random child of that child
-        IFunctionTree selectedChild = possibleChilds[random.Next(possibleChilds.Length)];        
+        IFunctionTree selectedChild = possibleChilds[random.Next(possibleChilds.Length)];
         parent.RemoveSubTree(childIndex);
         parent.InsertSubTree(childIndex, selectedChild);
-        Debug.Assert(gardener.IsValidTree(root));
-        // update the size and height of our tree
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = root.Size;
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = root.Height;
+        Debug.Assert(gardener.IsValidTree(gpModel.FunctionTree));
+        // recalculate the size and height of our tree
+        gpModel.Size = gpModel.FunctionTree.GetSize();
+        gpModel.Height = gpModel.FunctionTree.GetHeight();
         // don't need to schedule initialization operations
         return null;
@@ -113 +95 @@
         // can't reuse an existing branch => create a new tree
         // determine the level of the parent
-        int parentLevel = gardener.GetBranchLevel(root, parent);
+        int parentLevel = gardener.GetBranchLevel(gpModel.FunctionTree, parent);
         // first remove the old child (first step essential!)
         parent.RemoveSubTree(childIndex);
         // then determine the number of nodes left over after the child has been removed!
-        int remainingNodes = root.Size;
+        int remainingNodes = gpModel.FunctionTree.GetSize();
         allowedFunctions = gardener.GetAllowedSubFunctions(parent.Function, childIndex);
         IFunctionTree newFunctionTree = gardener.CreateRandomTree(allowedFunctions, maxTreeSize - remainingNodes, maxTreeHeight - parentLevel);
         parent.InsertSubTree(childIndex, newFunctionTree);
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = root.Size;
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = root.Height;
-        Debug.Assert(gardener.IsValidTree(root));
+        Debug.Assert(gardener.IsValidTree(gpModel.FunctionTree));
+        // recalculate size and height
+        gpModel.Size = gpModel.FunctionTree.GetSize();
+        gpModel.Height = gpModel.FunctionTree.GetHeight();
         // schedule an initialization operation for the new function-tree
-        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newFunctionTree), scope);
+        return TreeGardener.CreateInitializationOperation(TreeGardener.GetAllSubTrees(newFunctionTree), scope);
       }
     }

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Manipulation/DeleteSubTreeManipulation.cs

@@ -27 +27 @@
 using HeuristicLab.Random;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
-  public class DeleteSubTreeManipulation : OperatorBase {
+  public class DeleteSubTreeManipulation : GPManipulatorBase {
     public override string Description {
       get {
@@ -39 +40 @@
     public DeleteSubTreeManipulation()
       : base() {
-      AddVariableInfo(new VariableInfo("Random", "Uniform random number generator", typeof(MersenneTwister), VariableKind.In));
-      AddVariableInfo(new VariableInfo("OperatorLibrary", "The operator library containing all available operators", typeof(FunctionLibrary), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MaxTreeHeight", "The maximal allowed height of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MaxTreeSize", "The maximal allowed size (number of nodes) of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The tree to mutate", typeof(IFunctionTree), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeSize", "The size (number of nodes) of the tree", typeof(IntData), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeHeight", "The height of the tree", typeof(IntData), VariableKind.In | VariableKind.Out));
     }
 
-
-    public override IOperation Apply(IScope scope) {
-      IFunctionTree root = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
-      MersenneTwister random = GetVariableValue<MersenneTwister>("Random", scope, true);
-      FunctionLibrary library = GetVariableValue<FunctionLibrary>("OperatorLibrary", scope, true);
+    internal override IOperation Manipulate(MersenneTwister random, IGeneticProgrammingModel gpModel, FunctionLibrary library, int maxTreeSize, int maxTreeHeight, IScope scope) {
       TreeGardener gardener = new TreeGardener(random, library);
-      IFunctionTree parent = gardener.GetRandomParentNode(root);
+      IFunctionTree parent = gardener.GetRandomParentNode(gpModel.FunctionTree);
 
       // parent==null means the whole tree should be deleted.
       // => return a new minimal random tree
-      if(parent == null) {
+      if (parent == null) {
         IFunctionTree newTree = gardener.CreateBalancedRandomTree(1, 1);
         // check if the tree is ok
         Debug.Assert(gardener.IsValidTree(newTree));
-        // update sizes to match the new tree
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = newTree.Size;
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = newTree.Height;
-        scope.GetVariable(scope.TranslateName("FunctionTree")).Value = newTree;
-
+        gpModel.FunctionTree = newTree;
         // schedule an operation to initialize the newly created operator
-        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newTree), scope);
+        return TreeGardener.CreateInitializationOperation(TreeGardener.GetAllSubTrees(newTree), scope);
       }
 
       // select a branch to prune
       int childIndex = random.Next(parent.SubTrees.Count);
-      if(parent.SubTrees.Count > parent.Function.MinArity) {
+      if (parent.SubTrees.Count > parent.Function.MinArity) {
         parent.RemoveSubTree(childIndex);
         // actually since the next sub-trees are shifted in the place of the removed branch
@@ -81 +67 @@
         // and find the first one that doesn't fit. At this position we insert a new randomly initialized subtree of matching type (gkronber 25.12.07)
 
-        Debug.Assert(gardener.IsValidTree(root));
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = root.Size;
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = root.Height;
+        Debug.Assert(gardener.IsValidTree(gpModel.FunctionTree));
+        // recalculate size and height
+        gpModel.Size = gpModel.FunctionTree.GetSize();
+        gpModel.Height = gpModel.FunctionTree.GetHeight();
         // root hasn't changed so don't need to update 'FunctionTree' variable
         return null;
@@ -92 +79 @@
         IFunctionTree newFunctionTree = gardener.CreateRandomTree(allowedFunctions, 1, 1);
         parent.InsertSubTree(childIndex, newFunctionTree);
-        Debug.Assert(gardener.IsValidTree(root));
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = root.Size;
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = root.Height;
-        // again the root hasn't changed so we don't need to update the 'FunctionTree' variable
-        // but we have to return an initialization operation for the newly created tree
-        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newFunctionTree), scope);
+        Debug.Assert(gardener.IsValidTree(gpModel.FunctionTree));
+        // recalculate size and height
+        gpModel.Size = gpModel.FunctionTree.GetSize();
+        gpModel.Height = gpModel.FunctionTree.GetHeight();
+        // return an initialization operation for the newly created tree
+        return TreeGardener.CreateInitializationOperation(TreeGardener.GetAllSubTrees(newFunctionTree), scope);
       }
     }

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Manipulation/FullTreeShaker.cs

@@ -29 +29 @@
 using HeuristicLab.Data;
 using HeuristicLab.Selection;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -39 +40 @@
       : base() {
       AddVariableInfo(new VariableInfo("Random", "A random generator (uniform)", typeof(MersenneTwister), VariableKind.In));
-      AddVariableInfo(new VariableInfo("OperatorLibrary", "Operator library that defines operator mutations", typeof(FunctionLibrary), VariableKind.In));
+      AddVariableInfo(new VariableInfo("FunctionLibrary", "Function library that defines function mutations", typeof(FunctionLibrary), VariableKind.In));
       AddVariableInfo(new VariableInfo("ShakingFactor", "Variable that determines the force of the shaking operation", typeof(DoubleData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The function tree that should be mutated", typeof(IFunctionTree), VariableKind.In | VariableKind.Out));
+      AddVariableInfo(new VariableInfo("FunctionTree", "The function tree that should be mutated", typeof(IGeneticProgrammingModel), VariableKind.In | VariableKind.Out));
     }
 
     public override IOperation Apply(IScope scope) {
-      FunctionLibrary library = GetVariableValue<FunctionLibrary>("OperatorLibrary", scope, true);
-      IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", scope, false);
+      FunctionLibrary library = GetVariableValue<FunctionLibrary>("FunctionLibrary", scope, true);
+      IGeneticProgrammingModel gpModel = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope, false);
       MersenneTwister mt = GetVariableValue<MersenneTwister>("Random", scope, true);
 
-      // enqueue all mutation operations as parallel operations
+      // save all existing sub-scopes in a backup scope
+      Scope backupScope = new Scope("backup");
+      foreach (Scope subScope in scope.SubScopes) {
+        backupScope.AddSubScope(subScope);
+      }
+
+      // create a scope for all shaking operations
+      Scope tempScope = new Scope("Temp. manipulation scope");
+      scope.AddSubScope(tempScope); // scope containing a subscope for each manipulation
+      scope.AddSubScope(backupScope); // scope containing the old subscopes
+
+      // create a composite operation for all shaking operations
       CompositeOperation next = new CompositeOperation();
       next.ExecuteInParallel = false;
 
-      Scope tempScope = new Scope("Temp. manipulation scope");
-
-      TreeGardener gardener = new TreeGardener(mt, library);
-      var parametricBranches = gardener.GetAllSubTrees(tree).Where(branch => branch.Manipulator!= null);
-      foreach(IFunctionTree subTree in parametricBranches) {
-        IOperator mutation = subTree.Manipulator;
-
-        // store all local variables into a temporary scope
-        Scope mutationScope = new Scope();
-        foreach(IVariable variable in subTree.LocalVariables) {
-          mutationScope.AddVariable(variable);
-        }
-
-        tempScope.AddSubScope(mutationScope);
-        next.AddOperation(new AtomicOperation(mutation, mutationScope));
+      // enqueue all shaking operations
+      foreach (IFunctionTree subTree in TreeGardener.GetAllSubTrees(gpModel.FunctionTree).Where(x=>x.HasLocalParameters)) {
+        IOperation shakingOperation = subTree.CreateShakingOperation(tempScope);
+        next.AddOperation(shakingOperation);
       }
-
-      // save all existing sub-scopes in a backup scope
-      Scope backupScope = new Scope("backup");
-      foreach(Scope subScope in scope.SubScopes) {
-        backupScope.AddSubScope(subScope);
-      }
-
-      scope.AddSubScope(tempScope); // scope containing a subscope for each manipulation
-      scope.AddSubScope(backupScope); // scope containing the old subscopes
 
       // schedule a reducer operation to delete all temporary scopes and restore

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Manipulation/OnePointShaker.cs

@@ -29 +29 @@
 using HeuristicLab.Data;
 using HeuristicLab.Selection;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -38 +39 @@
     public OnePointShaker()
       : base() {
-      AddVariableInfo(new VariableInfo("OperatorLibrary", "Operator library that defines mutation operations for operators", typeof(FunctionLibrary), VariableKind.In));
+      AddVariableInfo(new VariableInfo("FunctionLibrary", "Function library that defines mutation operations for functions", typeof(FunctionLibrary), VariableKind.In));
       AddVariableInfo(new VariableInfo("Random", "A random generator (uniform)", typeof(MersenneTwister), VariableKind.In));
       AddVariableInfo(new VariableInfo("ShakingFactor", "Factor that determines the force of the shaking operation", typeof(DoubleData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The function tree that should be mutated", typeof(IFunctionTree), VariableKind.In | VariableKind.Out));
+      AddVariableInfo(new VariableInfo("FunctionTree", "The function tree that should be mutated", typeof(IGeneticProgrammingModel), VariableKind.In | VariableKind.Out));
     }
 
     public override IOperation Apply(IScope scope) {
-      FunctionLibrary library = GetVariableValue<FunctionLibrary>("OperatorLibrary", scope, true);
-      IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", scope, false);
+      FunctionLibrary library = GetVariableValue<FunctionLibrary>("FunctionLibrary", scope, true);
+      IGeneticProgrammingModel gpModel = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope, false);
       MersenneTwister mt = GetVariableValue<MersenneTwister>("Random", scope, true);
-      TreeGardener gardener = new TreeGardener(mt, library);
 
-      // get all nodes for which a manipulation is defined
-      var parametricBranches = gardener.GetAllSubTrees(tree).Where(branch => branch.Manipulator != null);
+      // get all nodes with local parameters
+      var parametricBranches = TreeGardener.GetAllSubTrees(gpModel.FunctionTree).Where(branch => branch.HasLocalParameters);
+      if (parametricBranches.Count() == 0) return null; // don't manipulate anything if there are no nodes with a manipulation operator
+      IFunctionTree selectedBranch = parametricBranches.ElementAt(mt.Next(parametricBranches.Count()));
 
-      if(parametricBranches.Count() == 0) return null; // don't manipulate anything if there are no nodes with a manipulation operator
-
-      IFunctionTree selectedBranch = parametricBranches.ElementAt(mt.Next(parametricBranches.Count()));
-      IOperator mutation = selectedBranch.Manipulator;
-      CompositeOperation next = new CompositeOperation();
-
-      // store all local variables into a temporary scope
-      Scope tempScope = new Scope("Temp. manipulation scope");
-      foreach(IVariable variable in selectedBranch.LocalVariables) {
-        tempScope.AddVariable(variable);
-      }
-
-      // save the exising sub-scops in a backup scope
+      // save the exising sub-scopes in a backup scope
       Scope backupScope = new Scope("backup");
       foreach (Scope subScope in scope.SubScopes) {
@@ -71 +61 @@
       }
 
+      // create a scope for all shaking operations
+      Scope tempScope = new Scope("Temp. manipulation scope");
+      
       // add the new sub-scopes
       scope.AddSubScope(tempScope);
       scope.AddSubScope(backupScope);
 
+      CompositeOperation next = new CompositeOperation();
+      next.ExecuteInParallel = false;
       // the next operation should first manipulate and then restore the sub-scopes from the backup scope
-      next.AddOperation(new AtomicOperation(mutation, tempScope));
+      next.AddOperation(selectedBranch.CreateShakingOperation(tempScope));
       next.AddOperation(new AtomicOperation(new RightReducer(), scope));
 

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Manipulation/SubstituteSubTreeManipulation.cs

@@ -28 +28 @@
 using HeuristicLab.Random;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
-  public class SubstituteSubTreeManipulation : OperatorBase {
+  public class SubstituteSubTreeManipulation : GPManipulatorBase {
 
     public override string Description {
@@ -38 +39 @@
     public SubstituteSubTreeManipulation()
       : base() {
-      AddVariableInfo(new VariableInfo("Random", "Uniform random number generator", typeof(MersenneTwister), VariableKind.In));
-      AddVariableInfo(new VariableInfo("OperatorLibrary", "The operator library containing all available operators", typeof(FunctionLibrary), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MaxTreeHeight", "The maximal allowed height of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MaxTreeSize", "The maximal allowed size (number of nodes) of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The tree to manipulate", typeof(IFunctionTree), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeSize", "The size (number of nodes) of the tree", typeof(IntData), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TreeHeight", "The height of the tree", typeof(IntData), VariableKind.In | VariableKind.Out));
     }
 
-    public override IOperation Apply(IScope scope) {
-      IFunctionTree root = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
-      MersenneTwister random = GetVariableValue<MersenneTwister>("Random", scope, true);
-      FunctionLibrary library = GetVariableValue<FunctionLibrary>("OperatorLibrary", scope, true);
-      int maxTreeHeight = GetVariableValue<IntData>("MaxTreeHeight", scope, true).Data;
-      int maxTreeSize = GetVariableValue<IntData>("MaxTreeSize", scope, true).Data;
-      int treeSize = GetVariableValue<IntData>("TreeSize", scope, true).Data;
-      int treeHeight = GetVariableValue<IntData>("TreeHeight", scope, true).Data;
+    internal override IOperation Manipulate(MersenneTwister random, IGeneticProgrammingModel gpModel, FunctionLibrary library, int maxTreeSize, int maxTreeHeight, IScope scope) {
       TreeGardener gardener = new TreeGardener(random, library);
-      IFunctionTree parent = gardener.GetRandomParentNode(root);
-      if(parent == null) {
+      IFunctionTree parent = gardener.GetRandomParentNode(gpModel.FunctionTree);
+      if (parent == null) {
         // parent == null means we should subsitute the whole tree
         // => create a new random tree
@@ -63 +50 @@
         Debug.Assert(gardener.IsValidTree(newTree));
 
-        // update the variables in the scope with the new values
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = newTree.Size;
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = newTree.Height;
-        scope.GetVariable(scope.TranslateName("FunctionTree")).Value = newTree;
-        
+        gpModel.FunctionTree = newTree;
         // return a CompositeOperation that randomly initializes the new tree
-        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newTree), scope);
+        return TreeGardener.CreateInitializationOperation(TreeGardener.GetAllSubTrees(newTree), scope);
       } else {
         // determine a random child of the parent to be replaced
@@ -75 +58 @@
         // get the list of allowed functions for the new sub-tree
         ICollection<IFunction> allowedFunctions = gardener.GetAllowedSubFunctions(parent.Function, childIndex);
-        if(allowedFunctions.Count == 0) {
+        if (allowedFunctions.Count == 0) {
           // don't change anything
           // this shouldn't happen
@@ -83 +66 @@
         // calculate the maximum size and height of the new sub-tree based on the location where
         // it will be inserted
-        int parentLevel = gardener.GetBranchLevel(root, parent);
+        int parentLevel = gardener.GetBranchLevel(gpModel.FunctionTree, parent);
         int maxSubTreeHeight = maxTreeHeight - parentLevel;
-        int maxSubTreeSize = maxTreeSize - (treeSize - parent.SubTrees[childIndex].Size);
+        int maxSubTreeSize = maxTreeSize - (gpModel.Size - parent.SubTrees[childIndex].GetSize());
 
         // create a random function tree
@@ -92 +75 @@
         parent.InsertSubTree(childIndex, newTree);
 
-        Debug.Assert(gardener.IsValidTree(root));
+        Debug.Assert(gardener.IsValidTree(gpModel.FunctionTree));
         // update the values of treeSize and treeHeight
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = root.Size;
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = root.Height;
+        gpModel.Size = gpModel.FunctionTree.GetSize();
+        gpModel.Height = gpModel.FunctionTree.GetHeight();
         // the root hasn't changed so we don't need to update 
         // return a CompositeOperation that randomly initializes all nodes of the new subtree
-        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newTree), scope);
+        return TreeGardener.CreateInitializationOperation(TreeGardener.GetAllSubTrees(newTree), scope);
       }
     }

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Recombination/GPCrossoverBase.cs

@@ -31 +31 @@
 using System.Diagnostics;
 using HeuristicLab.Evolutionary;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -36 +37 @@
     public GPCrossoverBase()
       : base() {
-      AddVariableInfo(new VariableInfo("OperatorLibrary", "The operator library containing all available operators", typeof(FunctionLibrary), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The tree to mutate", typeof(IFunctionTree), VariableKind.In | VariableKind.New));
-      AddVariableInfo(new VariableInfo("TreeSize", "The size (number of nodes) of the tree", typeof(IntData), VariableKind.New));
-      AddVariableInfo(new VariableInfo("TreeHeight", "The height of the tree", typeof(IntData), VariableKind.New));
+      AddVariableInfo(new VariableInfo("FunctionLibrary", "The operator library containing all available operators", typeof(FunctionLibrary), VariableKind.In));
+      AddVariableInfo(new VariableInfo("FunctionTree", "The tree to crossover", typeof(IGeneticProgrammingModel), VariableKind.In | VariableKind.New));
     }
 
@@ -45 +44 @@
 
     protected override void Cross(IScope scope, IRandom random) {
-      FunctionLibrary opLibrary = GetVariableValue<FunctionLibrary>("OperatorLibrary", scope, true);
+      FunctionLibrary opLibrary = GetVariableValue<FunctionLibrary>("FunctionLibrary", scope, true);
       TreeGardener gardener = new TreeGardener(random, opLibrary);
 
@@ -51 +50 @@
         throw new InvalidOperationException("Number of parents must be exactly two.");
 
-      IFunctionTree parent0 = GetVariableValue<IFunctionTree>("FunctionTree", scope.SubScopes[0], false);
-      IFunctionTree parent1 = GetVariableValue<IFunctionTree>("FunctionTree", scope.SubScopes[1], false);
+      IGeneticProgrammingModel parent0 = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope.SubScopes[0], false);
+      IGeneticProgrammingModel parent1 = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope.SubScopes[1], false);
 
       // randomly swap parents to remove a possible bias from selection (e.g. when using gender-specific selection)
       if (random.NextDouble() < 0.5) {
-        IFunctionTree tmp = parent0;
+        IGeneticProgrammingModel tmp = parent0;
         parent0 = parent1;
         parent1 = tmp;
       }
 
-      IFunctionTree child = Cross(scope, gardener, random, parent0, parent1);
+      IFunctionTree child = Cross(scope, gardener, random, parent0.FunctionTree, parent1.FunctionTree);
       Debug.Assert(gardener.IsValidTree(child));
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("FunctionTree"), child));
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TreeSize"), new IntData(child.Size)));
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TreeHeight"), new IntData(child.Height)));
+      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("FunctionTree"), new GeneticProgrammingModel(child)));
     }
   }

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Recombination/LangdonHomologousCrossOver.cs

@@ -30 +30 @@
 using HeuristicLab.Constraints;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Recombination/OnePointCrossOver.cs

@@ -30 +30 @@
 using HeuristicLab.Constraints;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -51 +52 @@
     internal override IFunctionTree Cross(TreeGardener gardener, IRandom random, IFunctionTree tree0, IFunctionTree tree1, int maxTreeSize, int maxTreeHeight) {
       List<CrossoverPoint> allowedCrossOverPoints = new List<CrossoverPoint>();
-      GetCrossOverPoints(gardener, tree0, tree1, maxTreeSize - tree0.Size, allowedCrossOverPoints);
+      GetCrossOverPoints(gardener, tree0, tree1, maxTreeSize - tree0.GetSize(), allowedCrossOverPoints);
       if (allowedCrossOverPoints.Count > 0) {
         CrossoverPoint crossOverPoint = allowedCrossOverPoints[random.Next(allowedCrossOverPoints.Count)];
@@ -68 +69 @@
         // if the current branch can be attached as a sub-tree to branch0
         if (gardener.GetAllowedSubFunctions(branch0.Function, i).Contains(branch1.SubTrees[i].Function) &&
-           branch1.SubTrees[i].Size - branch0.SubTrees[i].Size <= maxNewNodes) {
+           branch1.SubTrees[i].GetSize() - branch0.SubTrees[i].GetSize() <= maxNewNodes) {
           CrossoverPoint p = new CrossoverPoint();
           p.childIndex = i;

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Recombination/SizeConstrictedGPCrossoverBase.cs

@@ -30 +30 @@
 using HeuristicLab.Constraints;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -58 +59 @@
           newTree = Cross(gardener, random, (IFunctionTree)tree1.Clone(), (IFunctionTree)tree0.Clone(), maxTreeSize, maxTreeHeight);
         } else newTree = tree0;
-      } while (newTree.Size > maxTreeSize || newTree.Height > maxTreeHeight);
+      } while (newTree.GetSize() > maxTreeSize || newTree.GetHeight() > maxTreeHeight);
       return newTree;
     }
 
     internal abstract IFunctionTree Cross(TreeGardener gardener, IRandom random, IFunctionTree tree0, IFunctionTree tree1, int maxTreeSize, int maxTreeHeight);
-
-    //private IFunctionTree TakeNextParent(IScope scope) {
-    //  IFunctionTree parent = GetVariableValue<IFunctionTree>("FunctionTree", scope.SubScopes[0], false);
-    //  scope.RemoveSubScope(scope.SubScopes[0]);
-    //  return parent;
-    //}
   }
 }

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Recombination/SizeFairCrossOver.cs

@@ -30 +30 @@
 using HeuristicLab.Constraints;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -69 +70 @@
     private IFunctionTree GetReplacementBranch(MersenneTwister random, TreeGardener gardener, IFunctionTree intoTree, IFunctionTree parent, int replacedBranchIndex, IFunctionTree fromTree, int maxTreeSize, int maxTreeHeight) {
       IList<IFunction> allowedFunctions = new List<IFunction>(gardener.GetAllowedSubFunctions(parent.Function, replacedBranchIndex));
-      int removedBranchSize = parent.SubTrees[replacedBranchIndex].Size;
-      int maxBranchSize = maxTreeSize - (intoTree.Size - removedBranchSize);
+      int removedBranchSize = parent.SubTrees[replacedBranchIndex].GetSize();
+      int maxBranchSize = maxTreeSize - (intoTree.GetSize() - removedBranchSize);
       int maxBranchHeight = maxTreeHeight - gardener.GetBranchLevel(intoTree, parent);  // returns 1 if intoTree==parent and 2 if parent is a child of intoTree
       List<int> replacedTrail = GetTrail(intoTree, parent);
@@ -84 +85 @@
         double pEqualLength = equalLengthBranches.Count > 0 ? 1.0 / removedBranchSize : 0.0;
         double pLonger;
-        if (parent.Size == maxTreeSize) {
+        if (parent.GetSize() == maxTreeSize) {
           pLonger = 0.0;
         } else {
@@ -112 +113 @@
     private void FindPossibleBranches(IFunctionTree tree, IList<IFunction> allowedFunctions, int maxBranchSize, int maxBranchHeight, int removedBranchSize,
       List<CrossoverPoint> shorterBranches, List<CrossoverPoint> equalLengthBranches, List<CrossoverPoint> longerBranches, List<int> trail) {
-      int treeSize = tree.Size;
-      if (allowedFunctions.Contains(tree.Function) && treeSize <= maxBranchSize && tree.Height <= maxBranchHeight) {
+      int treeSize = tree.GetSize();
+      if (allowedFunctions.Contains(tree.Function) && treeSize <= maxBranchSize && tree.GetHeight() <= maxBranchHeight) {
         CrossoverPoint p = new CrossoverPoint();
         p.branchSize = treeSize;

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Recombination/StandardCrossOver.cs

@@ -30 +30 @@
 using HeuristicLab.Constraints;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -57 +58 @@
 
         // calculate the max size and height that the inserted branch can have 
-        int maxInsertedBranchSize = maxTreeSize - (tree0.Size - parent0.SubTrees[replacedChildIndex].Size);
+        int maxInsertedBranchSize = maxTreeSize - (tree0.GetSize() - parent0.SubTrees[replacedChildIndex].GetSize());
         int maxInsertedBranchHeight = maxTreeHeight - gardener.GetBranchLevel(tree0, parent0); // branchlevel is 1 if tree0==parent0
 
         IList<IFunction> allowedFunctions = new List<IFunction>(gardener.GetAllowedSubFunctions(parent0.Function, replacedChildIndex));
-        allowedCrossoverPoints = GetPossibleCrossoverPoints(gardener, tree1, maxInsertedBranchSize, maxInsertedBranchHeight, allowedFunctions);
+        allowedCrossoverPoints = GetPossibleCrossoverPoints(tree1, maxInsertedBranchSize, maxInsertedBranchHeight, allowedFunctions);
       } while (allowedCrossoverPoints.Count == 0 && tries++ < MaxRecombinationTries);
 
@@ -74 +75 @@
     }
 
-    private List<IFunctionTree> GetPossibleCrossoverPoints(TreeGardener gardener, IFunctionTree tree, int maxInsertedBranchSize, int maxInsertedBranchHeight, IList<IFunction> allowedFunctions) {
+    private List<IFunctionTree> GetPossibleCrossoverPoints(IFunctionTree tree, int maxInsertedBranchSize, int maxInsertedBranchHeight, IList<IFunction> allowedFunctions) {
       List<IFunctionTree> crossoverPoints = new List<IFunctionTree>();
-      foreach (IFunctionTree possiblePoint in gardener.GetAllSubTrees(tree)) {
-        if (allowedFunctions.Contains(possiblePoint.Function) && possiblePoint.Size <= maxInsertedBranchSize && possiblePoint.Height <= maxInsertedBranchHeight)
+      foreach (IFunctionTree possiblePoint in TreeGardener.GetAllSubTrees(tree)) {
+        if (allowedFunctions.Contains(possiblePoint.Function) && possiblePoint.GetSize() <= maxInsertedBranchSize && possiblePoint.GetHeight() <= maxInsertedBranchHeight)
           crossoverPoints.Add(possiblePoint);
       }

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Recombination/UniformCrossover.cs

@@ -30 +30 @@
 using HeuristicLab.Constraints;
 using System.Diagnostics;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/TreeGardener.cs

@@ -32 +32 @@
 using System.Collections;
 using HeuristicLab.Selection;
+using HeuristicLab.GP.Interfaces;
 
 namespace HeuristicLab.GP {
@@ -96 +97 @@
     }
 
-    internal IFunctionTree PTC2(IRandom random, int size, int maxDepth) {
-      return PTC2(random, GetRandomRoot(size, maxDepth), size, maxDepth);
-    }
-
-    internal IFunctionTree PTC2(IRandom random, IFunction rootF, int size, int maxDepth) {
-      IFunctionTree root = rootF.GetTreeNode();
-      if(size <= 1 || maxDepth <= 1) return root;
+    public IFunctionTree PTC2(int size, int maxDepth) {
+      return PTC2(GetRandomRoot(size, maxDepth), size, maxDepth);
+    }
+
+    private IFunctionTree PTC2(IFunction rootFunction, int size, int maxDepth) {
+      IFunctionTree root = rootFunction.GetTreeNode();
+      if (size <= 1 || maxDepth <= 1) return root;
       List<object[]> list = new List<object[]>();
       int currentSize = 1;
@@ -108 +109 @@
       int minArity = root.Function.MinArity;
       int maxArity = root.Function.MaxArity;
-      if(maxArity >= size) {
+      if (maxArity >= size) {
         maxArity = size;
       }
       int actualArity = random.Next(minArity, maxArity + 1);
       totalListMinSize += root.Function.MinTreeSize - 1;
-      for(int i = 0; i < actualArity; i++) {
+      for (int i = 0; i < actualArity; i++) {
         // insert a dummy sub-tree and add the pending extension to the list
         root.AddSubTree(null);
@@ -119 +120 @@
       }
 
-      while(list.Count > 0 && totalListMinSize + currentSize < size) {
+      while (list.Count > 0 && totalListMinSize + currentSize < size) {
         int randomIndex = random.Next(list.Count);
         object[] nextExtension = list[randomIndex];
@@ -126 +127 @@
         int a = (int)nextExtension[1];
         int d = (int)nextExtension[2];
-        if(d == maxDepth) {
+        if (d == maxDepth) {
           parent.RemoveSubTree(a);
           IFunctionTree branch = CreateRandomTree(GetAllowedSubFunctions(parent.Function, a), 1, 1);
           parent.InsertSubTree(a, branch); // insert a smallest possible tree
-          currentSize += branch.Size;
-          totalListMinSize -= branch.Size;
+          currentSize += branch.GetSize();
+          totalListMinSize -= branch.GetSize();
         } else {
-          IFunction selectedFunction = RandomSelect(GetAllowedSubFunctions(parent.Function, a).Where(
-            f => !IsTerminal(f) && f.MinTreeHeight + (d - 1) <= maxDepth).ToArray());
+          IFunction selectedFunction = TreeGardener.RandomSelect(random, GetAllowedSubFunctions(parent.Function, a).Where(
+            f => !TreeGardener.IsTerminal(f) && f.MinTreeHeight + (d - 1) <= maxDepth).ToArray());
           IFunctionTree newTree = selectedFunction.GetTreeNode();
           parent.RemoveSubTree(a);
@@ -143 +144 @@
           minArity = selectedFunction.MinArity;
           maxArity = selectedFunction.MaxArity;
-          if(maxArity >= size) {
+          if (maxArity >= size) {
             maxArity = size;
           }
           actualArity = random.Next(minArity, maxArity + 1);
-          for(int i = 0; i < actualArity; i++) {
+          for (int i = 0; i < actualArity; i++) {
             // insert a dummy sub-tree and add the pending extension to the list
             newTree.AddSubTree(null);
@@ -155 +156 @@
         }
       }
-      while(list.Count > 0) {
+      while (list.Count > 0) {
         int randomIndex = random.Next(list.Count);
         object[] nextExtension = list[randomIndex];
@@ -168 +169 @@
       return root;
     }
-
+ 
     /// <summary>
     /// selects a random function from allowedFunctions and creates a random (unbalanced) tree with maximal size and height.
@@ -197 +198 @@
       // build the tree 
       IFunctionTree root;
-      root = PTC2(random, selectedFunction, maxTreeSize, maxTreeHeight);
+      root = PTC2(selectedFunction, maxTreeSize, maxTreeHeight);
       return root;
     }
 
-    internal CompositeOperation CreateInitializationOperation(ICollection<IFunctionTree> trees, IScope scope) {
-      // needed for the parameter shaking operation
+    internal static CompositeOperation CreateInitializationOperation(ICollection<IFunctionTree> trees, IScope scope) {
+      // create a backup of sub scopes to restore after initialization
+      Scope backupScope = new Scope("backup");
+      foreach (Scope subScope in scope.SubScopes) {
+        backupScope.AddSubScope(subScope);
+      }
+
       CompositeOperation initializationOperation = new CompositeOperation();
       Scope tempScope = new Scope("Temp. initialization scope");
 
-      var parametricTrees = trees.Where(t => t.Initializer != null);
+      var parametricTrees = trees.Where(t => t.HasLocalParameters);
       foreach(IFunctionTree tree in parametricTrees) {
-        // enqueue an initialization operation for each operator with local variables 
-        IOperator initialization = tree.Initializer;
-        Scope initScope = new Scope();
-        // copy the local variables into a temporary scope used for initialization
-        foreach(IVariable variable in tree.LocalVariables) {
-          initScope.AddVariable(variable);
-        }
-        tempScope.AddSubScope(initScope);
-        initializationOperation.AddOperation(new AtomicOperation(initialization, initScope));
-      }
-      Scope backupScope = new Scope("backup");
-      foreach(Scope subScope in scope.SubScopes) {
-        backupScope.AddSubScope(subScope);
+        initializationOperation.AddOperation(tree.CreateInitOperation(tempScope));
       }
       scope.AddSubScope(tempScope);
@@ -246 +240 @@
     }
 
-    internal ICollection<IFunctionTree> GetAllSubTrees(IFunctionTree root) {
+    internal static ICollection<IFunctionTree> GetAllSubTrees(IFunctionTree root) {
       List<IFunctionTree> allTrees = new List<IFunctionTree>();
       TreeForEach(root, t => { allTrees.Add(t); });
@@ -375 +369 @@
       return parents;
     }
-    internal bool IsTerminal(IFunction f) {
+    internal static bool IsTerminal(IFunction f) {
       return f.MinArity == 0 && f.MaxArity == 0;
     }
@@ -388 +382 @@
 
     #region private utility methods
-    private IFunction GetRandomRoot(int maxTreeSize, int maxTreeHeight) {
+    public IFunction GetRandomRoot(int maxTreeSize, int maxTreeHeight) {
       if(maxTreeHeight == 1 || maxTreeSize == 1) {
         IFunction selectedTerminal = RandomSelect(terminals);
@@ -450 +444 @@
     }
 
-    private void TreeForEach(IFunctionTree tree, Action<IFunctionTree> action) {
+    private static void TreeForEach(IFunctionTree tree, Action<IFunctionTree> action) {
       action(tree);
       foreach(IFunctionTree subTree in tree.SubTrees) {
@@ -457 +451 @@
     }
 
-    private void GetBranchesAtLevel(IFunctionTree tree, int level, List<IFunctionTree> result) {
+    private static void GetBranchesAtLevel(IFunctionTree tree, int level, List<IFunctionTree> result) {
       if(level == 1) result.AddRange(tree.SubTrees);
       foreach(IFunctionTree subTree in tree.SubTrees) {
-        if(subTree.Height >= level - 1)
+        if(subTree.GetHeight() >= level - 1)
           GetBranchesAtLevel(subTree, level - 1, result);
       }
@@ -466 +460 @@
 
     private IFunction RandomSelect(IList<IFunction> functionSet) {
+      return RandomSelect(random, functionSet);
+    }
+
+    public static IFunction RandomSelect(IRandom random, IList<IFunction> functionSet) {
       double[] accumulatedTickets = new double[functionSet.Count];
       double ticketAccumulator = 0;
       int i = 0;
       // precalculate the slot-sizes
-      foreach(IFunction function in functionSet) {
+      foreach (IFunction function in functionSet) {
         ticketAccumulator += function.Tickets;
         accumulatedTickets[i] = ticketAccumulator;
@@ -478 +476 @@
       double r = random.NextDouble() * ticketAccumulator;
       // find the slot that has been hit
-      for(i = 0; i < accumulatedTickets.Length; i++) {
-        if(r < accumulatedTickets[i]) return functionSet[i];
+      for (i = 0; i < accumulatedTickets.Length; i++) {
+        if (r < accumulatedTickets[i]) return functionSet[i];
       }
       // sanity check