Changeset 143 for branches

Timestamp:

04/21/08 15:31:41 (17 years ago)

Author:

gkronber

Message:

worked on #112 in the refactoring branch

Location:

branches/FunctionsAndStructIdRefactoring

Files:

• HeuristicLab.Functions/IFunctionTree.cs (modified) (1 diff)
• HeuristicLab.StructureIdentification/Evaluation/MeanSquaredErrorEvaluator.cs (modified) (1 diff)
• HeuristicLab.StructureIdentification/Manipulation/ChangeNodeTypeManipulation.cs (modified) (3 diffs)
• HeuristicLab.StructureIdentification/Manipulation/CutOutNodeManipulation.cs (modified) (4 diffs)
• HeuristicLab.StructureIdentification/Manipulation/DeleteSubTreeManipulation.cs (modified) (4 diffs)
• HeuristicLab.StructureIdentification/Manipulation/FullTreeShaker.cs (modified) (3 diffs)
• HeuristicLab.StructureIdentification/Manipulation/OnePointShaker.cs (modified) (2 diffs)
• HeuristicLab.StructureIdentification/Manipulation/SubstituteSubTreeManipulation.cs (modified) (5 diffs)
• HeuristicLab.StructureIdentification/RandomTreeCreator.cs (modified) (1 diff)
• HeuristicLab.StructureIdentification/Recombination/SinglePointCrossOver.cs (modified) (11 diffs)
• HeuristicLab.StructureIdentification/TreeGardener.cs (modified) (23 diffs)
• HeuristicLab/UpdateLocalInstallation.cmd (modified) (1 diff)

branches/FunctionsAndStructIdRefactoring/HeuristicLab.Functions/IFunctionTree.cs

@@ -37 +37 @@
     void InsertSubTree(int index, IFunctionTree tree);
     void RemoveSubTree(int index);
+
     double Evaluate(Dataset dataset, int sampleIndex);
   }

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/Evaluation/MeanSquaredErrorEvaluator.cs

@@ -47 +47 @@
       double targetMean = dataset.GetMean(targetVariable);
       for(int sample = 0; sample < dataset.Rows; sample++) {
+
         double estimated = functionTree.Evaluate(dataset, sample);
         double original = dataset.GetValue(sample, targetVariable);

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/Manipulation/ChangeNodeTypeManipulation.cs

@@ -84 +84 @@
         // 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.GetAllOperators(newTerminal), scope);
+        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newTerminal), scope);
       } else {
         List<IFunctionTree> uninitializedBranches;
@@ -147 +147 @@
       IList<IOperator> allowedSubOperators;
       SubOperatorsConstraintAnalyser analyser = new SubOperatorsConstraintAnalyser();
-      analyser.AllPossibleOperators = gardener.AllOperators;
+      analyser.AllPossibleOperators = gardener.AllFunctions;
       if (parent == null) {
-        allowedSubOperators = gardener.AllOperators;
+        allowedSubOperators = gardener.AllFunctions;
       } else {
         allowedSubOperators = analyser.GetAllowedOperators(parent, childIndex);
@@ -203 +203 @@
             freshTree = gardener.CreateRandomTree(allowedOperators, maxSubTreeSize, maxSubTreeHeight, false);
           }
-          freshSubTrees.AddRange(gardener.GetAllOperators(freshTree));
+          freshSubTrees.AddRange(gardener.GetAllSubTrees(freshTree));
 
           newTree.InsertSubTree(i, freshTree);

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/Manipulation/CutOutNodeManipulation.cs

@@ -27 +27 @@
 using HeuristicLab.Random;
 using System;
+using HeuristicLab.Functions;
 
 namespace HeuristicLab.StructureIdentification {
@@ -32 +33 @@
     public override string Description {
       get {
-        return @"Takes a tree, selects a random node of the tree and then tries to replace a random child 
+        return @"Takes a tree, selects a random node of the tree and then tries to replace a random sub-tree
 of that node with one of the childs of the selected child.
 
@@ -53 +54 @@
       AddVariableInfo(new VariableInfo("MaxTreeSize", "The maximal allowed size (number of nodes) 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("OperatorTree", "The tree to mutate", typeof(IOperator), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TreeSize", "The size (number of nodes) of the tree", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TreeHeight", "The height 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) {
-      IOperator rootOperator = GetVariableValue<IOperator>("OperatorTree", scope, true);
+      IFunctionTree root = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
       MersenneTwister random = GetVariableValue<MersenneTwister>("Random", scope, true);
       GPOperatorLibrary library = GetVariableValue<GPOperatorLibrary>("OperatorLibrary", scope, true);
@@ -68 +69 @@
 
       TreeGardener gardener = new TreeGardener(random, library);
-      IOperator parent = gardener.GetRandomParentNode(rootOperator);
+      IFunctionTree parent = gardener.GetRandomParentNode(root);
       // parent == null means we should cut out the root node
-      // => return a random suboperator of the root
+      // => return a random sub-tree of the root
       if (parent == null) {
-        // when there are suboperators then replace the old operator with a random suboperator
-        if (rootOperator.SubOperators.Count > 0) {
-          rootOperator = rootOperator.SubOperators[random.Next(rootOperator.SubOperators.Count)];
+        // 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 = gardener.GetTreeSize(rootOperator);
-          GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(rootOperator);
+          GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(root);
+          GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(root);
 
-          // this is not really necessary (we can leave it in until the operator is stable)
-          if (!gardener.IsValidTree(rootOperator)) {
+          // this is not really necessary (we can leave it in until the tree is stable)
+          if (!gardener.IsValidTree(root)) {
             throw new InvalidProgramException();
           }
 
           // update the variable
-          scope.GetVariable("OperatorTree").Value = rootOperator;
-          if (!gardener.IsValidTree(rootOperator)) {
+          scope.GetVariable(scope.TranslateName("FunctionTree")).Value = root;
+          if (!gardener.IsValidTree(root)) {
             throw new InvalidProgramException();
           }
-
-
           // the tree is already initialized so we don't have to schedule initialization operations
           return null;
         } else {
           // create a new random tree
-          IOperator newOperator;
+          IFunctionTree newTree;
           if(random.NextDouble() <= balancedTreesRate) {
-            newOperator = gardener.CreateRandomTree(gardener.AllOperators, maxTreeSize, maxTreeHeight, true);
+            newTree = gardener.CreateRandomTree(gardener.AllFunctions, maxTreeSize, maxTreeHeight, true);
           } else {
-            newOperator = gardener.CreateRandomTree(gardener.AllOperators, maxTreeSize, maxTreeHeight, false);
+            newTree = gardener.CreateRandomTree(gardener.AllFunctions, maxTreeSize, maxTreeHeight, false);
           }
 
-          GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(newOperator);
-          GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(newOperator);
+          GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(newTree);
+          GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(newTree);
 
-          if (!gardener.IsValidTree(newOperator)) {
+          // update the variable
+          scope.GetVariable(scope.TranslateName("FunctionTree")).Value = newTree;
+
+          if (!gardener.IsValidTree(newTree)) {
             throw new InvalidProgramException();
           }
 
-          // update the variable
-          scope.GetVariable("OperatorTree").Value = newOperator;
-
-          if (!gardener.IsValidTree(newOperator)) {
-            throw new InvalidProgramException();
-          }
-
-          // schedule an operation to initialize the whole operator graph
-          return gardener.CreateInitializationOperation(gardener.GetAllOperators(newOperator), scope);
+          // schedule an operation to initialize the whole tree
+          return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newTree), scope);
         }
       }
 
-      int childIndex = random.Next(parent.SubOperators.Count);
-      IOperator child = parent.SubOperators[childIndex];
+      int childIndex = random.Next(parent.SubTrees.Count);
+      IFunctionTree child = parent.SubTrees[childIndex];
 
-      // match the suboperators of the child with the allowed suboperators of the parent
-      IOperator[] possibleChilds = gardener.GetAllowedSubOperators(parent, childIndex).SelectMany(allowedOp => child.SubOperators
-        .Where(subOp => ((StringData)subOp.GetVariable(GPOperatorLibrary.TYPE_ID).Value).Data ==
-          ((StringData)allowedOp.GetVariable(GPOperatorLibrary.TYPE_ID).Value).Data)).ToArray();
-
+      // match the sub-trees of the child with the allowed sub-trees of the parent
+      IFunction[] possibleChilds = gardener.GetAllowedSubFunctions(parent.Function, childIndex).SelectMany(allowedFun => child.SubTrees
+        .Where(subTree => allowedFun == subTree.Function)).Select(t=>t.Function).ToArray(); // Actually we should probably use OperatorEqualityComparer here (gkronber 21.04.08)
 
       if (possibleChilds.Length > 0) {
         // replace child with a random child of the child
-        // make a clone to simplify removing obsolete operators from the operator-graph
-        IOperator selectedChild = (IOperator)possibleChilds[random.Next(possibleChilds.Length)].Clone();        
-        parent.RemoveSubOperator(childIndex);
-        parent.AddSubOperator(selectedChild, childIndex);
+        // make a clone to simplify removing obsolete branches from the function-tree
+        IFunction selectedChild = possibleChilds[random.Next(possibleChilds.Length)];        
+        parent.RemoveSubTree(childIndex);
+        parent.InsertSubTree(childIndex, new FunctionTree(selectedChild));
 
-        if (!gardener.IsValidTree(rootOperator)) {
+        if (!gardener.IsValidTree(root)) {
           throw new InvalidProgramException();
         }
 
         // update the size and height of our tree
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(rootOperator);
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(rootOperator);
+        GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(root);
+        GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(root);
         // don't need to schedule initialization operations
         return null;
       } else {
         // determine the level of the parent
-        int parentLevel = gardener.GetNodeLevel(rootOperator, parent);
+        int parentLevel = gardener.GetBranchLevel(root, parent);
 
         // first remove the old child (first step essential!)
-        parent.RemoveSubOperator(childIndex);
+        parent.RemoveSubTree(childIndex);
         // then determine the number of nodes left over after the child has been removed!
-        int remainingNodes = gardener.GetTreeSize(rootOperator);
+        int remainingNodes = gardener.GetTreeSize(root);
 
-        IList<IOperator> allowedOperators = gardener.GetAllowedSubOperators(parent, childIndex);
-        IOperator newOperatorTree = gardener.CreateRandomTree(allowedOperators, maxTreeSize - remainingNodes, maxTreeHeight - parentLevel, true);
+        IList<IFunction> allowedFunctions = gardener.GetAllowedSubFunctions(parent.Function, childIndex);
+        IFunctionTree newFunctionTree = gardener.CreateRandomTree(allowedFunctions, maxTreeSize - remainingNodes, maxTreeHeight - parentLevel, true);
 
-        parent.AddSubOperator(newOperatorTree, childIndex);
+        parent.InsertSubTree(childIndex, newFunctionTree);
 
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(rootOperator);
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(rootOperator);
+        GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(root);
+        GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(root);
 
-        if (!gardener.IsValidTree(rootOperator)) {
+        if (!gardener.IsValidTree(root)) {
           throw new InvalidProgramException();
         }
 
-        // schedule an initialization operation for the new operator
-        return gardener.CreateInitializationOperation(gardener.GetAllOperators(newOperatorTree), scope);
+        // schedule an initialization operation for the new function-tree
+        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newFunctionTree), scope);
       }
     }

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/Manipulation/DeleteSubTreeManipulation.cs

@@ -26 +26 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Random;
+using HeuristicLab.Functions;
 
 namespace HeuristicLab.StructureIdentification {
@@ -42 +43 @@
       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("OperatorTree", "The tree to mutate", typeof(IOperator), VariableKind.In | VariableKind.Out));
+      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));
@@ -49 +50 @@
 
     public override IOperation Apply(IScope scope) {
-      IOperator rootOperator = GetVariableValue<IOperator>("OperatorTree", scope, true);
+      IFunctionTree root = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
       MersenneTwister random = GetVariableValue<MersenneTwister>("Random", scope, true);
       GPOperatorLibrary library = GetVariableValue<GPOperatorLibrary>("OperatorLibrary", scope, true);
-
       TreeGardener gardener = new TreeGardener(random, library);
-
-      IOperator parent = gardener.GetRandomParentNode(rootOperator);
+      IFunctionTree parent = gardener.GetRandomParentNode(root);
 
       // parent==null means the whole tree should be deleted.
       // => return a new minimal random tree
       if(parent == null) {
-        IOperator newTree = gardener.CreateRandomTree(1, 1, true);
+        IFunctionTree newTree = gardener.CreateRandomTree(1, 1, true);
 
         // check if the tree is ok
@@ -70 +69 @@
         GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(newTree);
         GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(newTree);
-        scope.GetVariable("OperatorTree").Value = newTree;
+        scope.GetVariable(scope.TranslateName("FunctionTree")).Value = newTree;
 
         // schedule an operation to initialize the newly created operator
-        return gardener.CreateInitializationOperation(gardener.GetAllOperators(newTree), scope);
+        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newTree), scope);
       }
 
-      int childIndex = random.Next(parent.SubOperators.Count);
+      int childIndex = random.Next(parent.SubTrees.Count);
 
       int min;
       int max;
-      gardener.GetMinMaxArity(parent, out min, out max);
-      if(parent.SubOperators.Count > min) {
-        parent.RemoveSubOperator(childIndex);
-        // actually since the next suboperators are shifted in the place of the removed operator
-        // it might be possible that these suboperators are not allowed in the place of the old operator
+      gardener.GetMinMaxArity(parent.Function, out min, out max);
+      if(parent.SubTrees.Count > min) {
+        parent.RemoveSubTree(childIndex);
+        // actually since the next sub-trees are shifted in the place of the removed branch
+        // it might be possible that these sub-trees are not allowed in the place of the old branch
         // we ignore this problem for now.
-        // when this starts to become a problem a possible solution is to go through the shifted operators from the place of the shifted
+        // when this starts to become a problem a possible solution is to go through the shifted branches from the place of the shifted
         // 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)
 
-        if(!gardener.IsValidTree(rootOperator)) {
+        if(!gardener.IsValidTree(root)) {
           throw new InvalidOperationException();
         }
 
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(rootOperator);
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(rootOperator);
-        // root hasn't changed so don't need to update 'OperatorTree' variable
-
+        GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(root);
+        GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(root);
+        // root hasn't changed so don't need to update 'FunctionTree' variable
         return null;
       } else {
         // replace with a minimal random seedling
-        parent.RemoveSubOperator(childIndex);
+        parent.RemoveSubTree(childIndex);
 
-        IList<IOperator> allowedOperators = gardener.GetAllowedSubOperators(parent, childIndex);
-        IOperator newOperatorTree = gardener.CreateRandomTree(allowedOperators, 1, 1, true);
+        IList<IFunction> allowedFunctions = gardener.GetAllowedSubFunctions(parent.Function, childIndex);
+        IFunctionTree newFunctionTree = gardener.CreateRandomTree(allowedFunctions, 1, 1, true);
 
-        parent.AddSubOperator(newOperatorTree, childIndex);
+        parent.InsertSubTree(childIndex, newFunctionTree);
 
-        if(!gardener.IsValidTree(rootOperator)) {
+        if(!gardener.IsValidTree(root)) {
           throw new InvalidProgramException();
         }
 
-        GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(rootOperator);
-        GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(rootOperator);
-        // again the root hasn't changed so we don't need to update the 'OperatorTree' variable
-
-        return gardener.CreateInitializationOperation(gardener.GetAllOperators(newOperatorTree), scope);
+        GetVariableValue<IntData>("TreeSize", scope, true).Data = gardener.GetTreeSize(root);
+        GetVariableValue<IntData>("TreeHeight", scope, true).Data = gardener.GetTreeHeight(root);
+        // again the root hasn't changed so we don't need to update the 'FunctionTree' variable
+        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newFunctionTree), scope);
       }
     }

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/Manipulation/FullTreeShaker.cs

@@ -29 +29 @@
 using HeuristicLab.Data;
 using HeuristicLab.Selection;
+using HeuristicLab.Functions;
 
 namespace HeuristicLab.StructureIdentification {
@@ -38 +39 @@
     public FullTreeShaker()
       : base() {
+      AddVariableInfo(new VariableInfo("Random", "A random generator (uniform)", typeof(MersenneTwister), VariableKind.In));
       AddVariableInfo(new VariableInfo("OperatorLibrary", "Operator library that defines operator mutations", typeof(GPOperatorLibrary), VariableKind.In));
-      AddVariableInfo(new VariableInfo("OperatorTree", "The operator tree that should be mutated", typeof(IOperator), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Random", "A random generator (uniform)", typeof(MersenneTwister), VariableKind.In));
-      AddVariableInfo(new VariableInfo("ShakingFactor", "Variable that determines the force of the shakeing operation", typeof(DoubleData), 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));
     }
 
     public override IOperation Apply(IScope scope) {
       GPOperatorLibrary library = GetVariableValue<GPOperatorLibrary>("OperatorLibrary", scope, true);
-      IOperator op = GetVariableValue<IOperator>("OperatorTree", scope, false);
+      IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", scope, false);
       MersenneTwister mt = GetVariableValue<MersenneTwister>("Random", scope, true);
 
@@ -56 +57 @@
 
       TreeGardener gardener = new TreeGardener(mt, library);
-      var parametricNodes = gardener.GetAllOperators(op).Where(o => o.GetVariable(GPOperatorLibrary.MANIPULATION) != null);
-      foreach(IOperator subOperator in parametricNodes) {
-        IOperator mutation =(IOperator)subOperator.GetVariable(GPOperatorLibrary.MANIPULATION).Value;
+      var parametricBranches = gardener.GetAllSubTrees(tree).Where(branch => branch.Function.GetVariable(GPOperatorLibrary.MANIPULATION) != null);
+      foreach(IFunctionTree subTree in parametricBranches) {
+        IOperator mutation =(IOperator)subTree.Function.GetVariable(GPOperatorLibrary.MANIPULATION).Value;
 
         // store all local variables into a temporary scope
         Scope mutationScope = new Scope();
-        foreach(IVariableInfo info in subOperator.VariableInfos) {
-          if(info.Local) {
-            mutationScope.AddVariable(subOperator.GetVariable(info.FormalName));
-          }
+        foreach(IVariable variable in subTree.LocalVariables) {
+          mutationScope.AddVariable(variable);
         }
 

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/Manipulation/OnePointShaker.cs

@@ -29 +29 @@
 using HeuristicLab.Data;
 using HeuristicLab.Selection;
+using HeuristicLab.Functions;
 
 namespace HeuristicLab.StructureIdentification {
@@ -39 +40 @@
       : base() {
       AddVariableInfo(new VariableInfo("OperatorLibrary", "Operator library that defines mutation operations for operators", typeof(GPOperatorLibrary), VariableKind.In));
-      AddVariableInfo(new VariableInfo("OperatorTree", "The operator tree that should be mutated", typeof(IOperator), 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));
     }
 
     public override IOperation Apply(IScope scope) {
       GPOperatorLibrary library = GetVariableValue<GPOperatorLibrary>("OperatorLibrary", scope, true);
-      IOperator op = GetVariableValue<IOperator>("OperatorTree", scope, false);
+      IFunctionTree tree = GetVariableValue<IFunctionTree>("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 parametricNodes = gardener.GetAllOperators(op).Where(o => o.GetVariable(GPOperatorLibrary.MANIPULATION) != null);
-      IOperator selectedOp = parametricNodes.ElementAt(mt.Next(parametricNodes.Count()));
-
-      IOperator mutation = (IOperator)selectedOp.GetVariable(GPOperatorLibrary.MANIPULATION).Value;
-
+      var parametricBranches = gardener.GetAllSubTrees(tree).Where(branch => branch.Function.GetVariable(GPOperatorLibrary.MANIPULATION) != null);
+      IFunctionTree selectedBranch = parametricBranches.ElementAt(mt.Next(parametricBranches.Count()));
+      IOperator mutation = (IOperator)selectedBranch.Function.GetVariable(GPOperatorLibrary.MANIPULATION).Value;
       CompositeOperation next = new CompositeOperation();
 
       // store all local variables into a temporary scope
       Scope tempScope = new Scope("Temp. manipulation scope");
-      // add aliases
-      foreach(IVariableInfo variableInfo in VariableInfos)
-        tempScope.AddAlias(variableInfo.FormalName, variableInfo.ActualName);
-
-      foreach(IVariableInfo info in selectedOp.VariableInfos) {
-        if(info.Local) {
-          tempScope.AddVariable(selectedOp.GetVariable(info.FormalName));
-        }
+      foreach(IVariable variable in selectedBranch.LocalVariables) {
+        tempScope.AddVariable(variable);
       }
 

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/Manipulation/SubstituteSubTreeManipulation.cs

@@ -69 +69 @@
         IOperator newOperatorTree;
         if(random.NextDouble() <= balancedTreesRate) {
-          newOperatorTree = gardener.CreateRandomTree(gardener.AllOperators, maxTreeSize, maxTreeHeight, true);
+          newOperatorTree = gardener.CreateRandomTree(gardener.AllFunctions, maxTreeSize, maxTreeHeight, true);
         } else {
-          newOperatorTree = gardener.CreateRandomTree(gardener.AllOperators, maxTreeSize, maxTreeHeight, false);
+          newOperatorTree = gardener.CreateRandomTree(gardener.AllFunctions, maxTreeSize, maxTreeHeight, false);
         }
 
@@ -84 +84 @@
         
         // return a CompositeOperation that randomly initializes the new operator
-        return gardener.CreateInitializationOperation(gardener.GetAllOperators(newOperatorTree), scope);
+        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newOperatorTree), scope);
       } else {
         // determine a random child of the parent to be replaced
@@ -90 +90 @@
 
         // get the list of allowed suboperators as the new child
-        IList<IOperator> allowedOperators = gardener.GetAllowedSubOperators(parent, childIndex);
+        IList<IOperator> allowedOperators = gardener.GetAllowedSubFunctions(parent, childIndex);
 
         if(allowedOperators.Count == 0) {
@@ -100 +100 @@
         // calculate the maximum size and height of the new sub-tree based on the location where
         // it will be inserted
-        int parentLevel = gardener.GetNodeLevel(rootOperator, parent);
+        int parentLevel = gardener.GetBranchLevel(rootOperator, parent);
 
         int maxSubTreeHeight = maxTreeHeight - parentLevel;
@@ -127 +127 @@
 
         // return a CompositeOperation that randomly initializes all nodes of the new subtree
-        return gardener.CreateInitializationOperation(gardener.GetAllOperators(newOperatorTree), scope);
+        return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(newOperatorTree), scope);
       }
     }

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/RandomTreeCreator.cs

@@ -78 +78 @@
       }
 
-      return gardener.CreateInitializationOperation(gardener.GetAllOperators(root), scope);
+      return gardener.CreateInitializationOperation(gardener.GetAllSubTrees(root), scope);
     }
   }

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/Recombination/SinglePointCrossOver.cs

@@ -81 +81 @@
     private IOperation Cross(TreeGardener gardener, int maxTreeSize, int maxTreeHeight,
       IScope scope, MersenneTwister random, IScope parent1, IScope parent2, IScope child) {
-      List<IOperator> newOperators;
-      IOperator newTree = Cross(gardener, parent1, parent2,
-        random, maxTreeSize, maxTreeHeight, out newOperators);
+      List<IFunctionTree> newBranches;
+      IFunctionTree newTree = Cross(gardener, parent1, parent2,
+        random, maxTreeSize, maxTreeHeight, out newBranches);
 
       if(!gardener.IsValidTree(newTree)) {
@@ -91 +91 @@
       int newTreeSize = gardener.GetTreeSize(newTree);
       int newTreeHeight = gardener.GetTreeHeight(newTree);
-      child.AddVariable(new Variable("FunctionTree", newTree));
-      child.AddVariable(new Variable("TreeSize", new IntData(newTreeSize)));
-      child.AddVariable(new Variable("TreeHeight", new IntData(newTreeHeight)));
+      child.AddVariable(new HeuristicLab.Core.Variable("FunctionTree", newTree));
+      child.AddVariable(new HeuristicLab.Core.Variable("TreeSize", new IntData(newTreeSize)));
+      child.AddVariable(new HeuristicLab.Core.Variable("TreeHeight", new IntData(newTreeHeight)));
 
       // check if the size of the new tree is still in the allowed bounds
@@ -100 +100 @@
         throw new InvalidProgramException();
       }
-
-
-      return gardener.CreateInitializationOperation(newOperators, child);
+      return gardener.CreateInitializationOperation(newBranches, child);
     }
 
@@ -133 +131 @@
         int tree0Level = random.Next(tree0Height - 1); // since we checked before that the height of tree0 is > 1 this is OK
         int tree1Level = random.Next(tree1Height);
-        tree0 = gardener.GetRandomNode(tree0, tree0Level);
-        tree1 = gardener.GetRandomNode(tree1, tree1Level);
+        tree0 = gardener.GetRandomBranch(tree0, tree0Level);
+        tree1 = gardener.GetRandomBranch(tree1, tree1Level);
 
         // recalculate the size and height of tree1 (the one that we want to insert) because we need to check constraints later on
@@ -141 +139 @@
 
         List<int> possibleChildIndices = new List<int>();
-        TreeGardener.OperatorEqualityComparer comparer = new TreeGardener.OperatorEqualityComparer();
+        TreeGardener.FunctionEqualityComparer comparer = new TreeGardener.FunctionEqualityComparer();
 
         // Now tree0 is supposed to take tree1 as one if its children. If this is not possible,
@@ -148 +146 @@
         // find the list of allowed indices (regarding allowed sub-operators, maxTreeSize and maxTreeHeight)
         for(int i = 0; i < tree0.SubTrees.Count; i++) {
-          int subOperatorSize = gardener.GetTreeSize(tree0.SubTrees[i]);
-
-          // the index is ok when the operator is allowed as sub-operator and we don't violate the maxSize and maxHeight constraints
-          if(GetAllowedOperators(tree0, i).Contains(tree1, comparer) &&
-            rootSize - subOperatorSize + tree1Size < maxTreeSize &&
+          int subTreeSize = gardener.GetTreeSize(tree0.SubTrees[i]);
+
+          // the index is ok when the function is allowed as sub-tree and we don't violate the maxSize and maxHeight constraints
+          if(GetAllowedOperators(tree0.Function, i).Contains(tree1.Function, comparer) &&
+            rootSize - subTreeSize + tree1Size < maxTreeSize &&
             tree0Level + tree1Height < maxTreeHeight) {
             possibleChildIndices.Add(i);
@@ -171 +169 @@
             // go up in tree0 
             tree0Level--;
-            tree0 = gardener.GetRandomNode(root, tree0Level);
+            tree0 = gardener.GetRandomBranch(root, tree0Level);
           } else if(tree1.SubTrees.Count > 0) {
             // go down in node2:
@@ -185 +183 @@
           possibleChildIndices.Clear();
           for(int i = 0; i < tree0.SubTrees.Count; i++) {
-            int subOperatorSize = gardener.GetTreeSize(tree0.SubTrees[i]);
-
-            // when the operator is allowed as sub-operator and we don't violate the maxSize and maxHeight constraints
+            int subTreeSize = gardener.GetTreeSize(tree0.SubTrees[i]);
+
+            // when the function is allowed as sub-tree and we don't violate the maxSize and maxHeight constraints
             // the index is ok
-            if(GetAllowedOperators(tree0, i).Contains(tree1, comparer) &&
-              rootSize - subOperatorSize + tree1Size < maxTreeSize &&
+            if(GetAllowedOperators(tree0.Function, i).Contains(tree1.Function, comparer) &&
+              rootSize - subTreeSize + tree1Size < maxTreeSize &&
               tree0Level + tree1Height < maxTreeHeight) {
               possibleChildIndices.Add(i);
@@ -205 +203 @@
         int selectedIndex = possibleChildIndices[random.Next(possibleChildIndices.Count)];
         tree0.RemoveSubTree(selectedIndex);
-        tree0.AddSubTree(tree1, selectedIndex);
+        tree0.InsertSubTree(selectedIndex, tree1);
 
         // no new operators where needed
@@ -213 +211 @@
     }
 
-    private ICollection<IOperator> GetAllowedOperators(IOperator tree0, int i) {
-      ItemList slotList = (ItemList)tree0.GetVariable(GPOperatorLibrary.ALLOWED_SUBOPERATORS).Value;
-      return ((ItemList)slotList[i]).OfType<IOperator>().ToArray();
+    private ICollection<IFunction> GetAllowedOperators(IFunction f, int i) {
+      ItemList slotList = (ItemList)f.GetVariable(GPOperatorLibrary.ALLOWED_SUBOPERATORS).Value;
+      return ((ItemList)slotList[i]).Cast<IFunction>().ToArray();
     }
 
     private IFunctionTree CombineTerminals(TreeGardener gardener, IFunctionTree f, IFunctionTree g, MersenneTwister random, int maxTreeHeight, out List<IFunctionTree> newBranches) {
       newBranches = new List<IFunctionTree>();
-      ICollection<IOperator> possibleParents = gardener.GetPossibleParents(new List<IOperator>() { f.Function, g.Function });
+      ICollection<IFunction> possibleParents = gardener.GetPossibleParents(new List<IFunction>() { f.Function, g.Function });
       if(possibleParents.Count == 0) throw new InvalidProgramException();
 
-      IOperator parent = (IOperator)possibleParents.ElementAt(random.Next(possibleParents.Count())).Clone();
+      IFunctionTree parent = new FunctionTree(possibleParents.ElementAt(random.Next(possibleParents.Count())));
 
       int minArity;
       int maxArity;
-      gardener.GetMinMaxArity(parent, out minArity, out maxArity);
+      gardener.GetMinMaxArity(parent.Function, out minArity, out maxArity);
 
       int nSlots = Math.Max(2, minArity);
 
-      HashSet<IOperator>[] slotSets = new HashSet<IOperator>[nSlots];
+      HashSet<IFunction>[] slotSets = new HashSet<IFunction>[nSlots];
 
       SubOperatorsConstraintAnalyser analyser = new SubOperatorsConstraintAnalyser();
       analyser.AllPossibleOperators = new List<IOperator>() { g.Function, f.Function };
       for(int slot = 0; slot < nSlots; slot++) {
-        HashSet<IOperator> slotSet = new HashSet<IOperator>(analyser.GetAllowedOperators(parent, slot));
+        HashSet<IFunction> slotSet = new HashSet<IFunction>(analyser.GetAllowedOperators(parent.Function, slot).Cast<IFunction>());
         slotSets[slot] = slotSet;
       }
@@ -242 +240 @@
       int[] slotSequence = Enumerable.Range(0, slotSets.Count()).OrderBy(slot => slotSets[slot].Count()).ToArray();
 
-      IOperator[] selectedOperators = new IOperator[nSlots];
+      IFunctionTree[] selectedFunctionTrees = new IFunctionTree[nSlots];
       for(int i = 0; i < slotSequence.Length; i++) {
         int slot = slotSequence[i];
-        HashSet<IOperator> slotSet = slotSets[slot];
+        HashSet<IFunction> slotSet = slotSets[slot];
         if(slotSet.Count() == 0) {
-          var allowedOperators = GetAllowedOperators(parent, slot);
-          selectedOperators[slot] = gardener.CreateRandomTree(allowedOperators, 1, 1, true);
-          newBranches.AddRange(gardener.GetAllOperators(selectedOperators[slot]));
+          var allowedFunctions = GetAllowedOperators(parent.Function, slot);
+          selectedFunctionTrees[slot] = gardener.CreateRandomTree(allowedFunctions, 1, 1, true);
+          newBranches.AddRange(gardener.GetAllSubTrees(selectedFunctionTrees[slot]));
         } else {
-          IOperator selectedOperator = slotSet.ElementAt(random.Next(slotSet.Count()));
-          selectedOperators[slot] = selectedOperator;
+          IFunction selectedFunction = slotSet.ElementAt(random.Next(slotSet.Count()));
+          selectedFunctionTrees[slot] = new FunctionTree(selectedFunction);
           for(int j = i + 1; j < slotSequence.Length; j++) {
             int otherSlot = slotSequence[j];
-            slotSets[otherSlot].Remove(selectedOperator);
-          }
-        }
-      }
-
-      for(int i = 0; i < selectedOperators.Length; i++) {
-        parent.AddSubOperator(selectedOperators[i], i);
+            slotSets[otherSlot].Remove(selectedFunction);
+          }
+        }
+      }
+
+      for(int i = 0; i < selectedFunctionTrees.Length; i++) {
+        parent.InsertSubTree(i, selectedFunctionTrees[i]);
       }
 

branches/FunctionsAndStructIdRefactoring/HeuristicLab.StructureIdentification/TreeGardener.cs

@@ -36 +36 @@
   internal class TreeGardener {
     private IRandom random;
-    private IOperatorLibrary opLibrary;
-    private List<IOperator> functions;
-    private List<IOperator> terminals;
-
-    internal IList<IOperator> Terminals {
+    private IOperatorLibrary funLibrary;
+    private List<IFunction> functions;
+    private List<IFunction> terminals;
+
+    internal IList<IFunction> Terminals {
       get { return terminals.AsReadOnly(); }
     }
-    private List<IOperator> allOperators;
-
-    internal IList<IOperator> AllOperators {
-      get { return allOperators.AsReadOnly(); }
-    }
-
-    internal TreeGardener(IRandom random, IOperatorLibrary opLibrary) {
+    private List<IFunction> allFunctions;
+
+    internal IList<IFunction> AllFunctions {
+      get { return allFunctions.AsReadOnly(); }
+    }
+
+    internal TreeGardener(IRandom random, IOperatorLibrary funLibrary) {
       this.random = random;
-      this.opLibrary = opLibrary;
-
-      this.allOperators = new List<IOperator>();
-      terminals = new List<IOperator>();
-      functions = new List<IOperator>();
+      this.funLibrary = funLibrary;
+
+      this.allFunctions = new List<IFunction>();
+      terminals = new List<IFunction>();
+      functions = new List<IFunction>();
 
       // init functions and terminals based on constraints
-      foreach (IOperator op in opLibrary.Group.Operators) {
+      foreach (IFunction fun in funLibrary.Group.Operators) {
         int maxA, minA;
-        GetMinMaxArity(op, out minA, out maxA);
+        GetMinMaxArity(fun, out minA, out maxA);
         if (maxA == 0) {
-          terminals.Add(op);
+          terminals.Add(fun);
         } else {
-          functions.Add(op);
-        }
-      }
-
-      allOperators.AddRange(functions);
-      allOperators.AddRange(terminals);
+          functions.Add(fun);
+        }
+      }
+
+      allFunctions.AddRange(functions);
+      allFunctions.AddRange(terminals);
     }
 
     #region random initialization
-    internal IFunctionTree CreateRandomTree(ICollection<IOperator> allowedOperators, int maxTreeSize, int maxTreeHeight, bool balanceTrees) {
-
-      int minTreeHeight = allowedOperators.Select(op => ((IntData)op.GetVariable(GPOperatorLibrary.MIN_TREE_HEIGHT).Value).Data).Min();
+    internal IFunctionTree CreateRandomTree(ICollection<IFunction> allowedFunctions, int maxTreeSize, int maxTreeHeight, bool balanceTrees) {
+
+      int minTreeHeight = allowedFunctions.Select(f => ((IntData)f.GetVariable(GPOperatorLibrary.MIN_TREE_HEIGHT).Value).Data).Min();
       if (minTreeHeight > maxTreeHeight)
         maxTreeHeight = minTreeHeight;
 
-      int minTreeSize = allowedOperators.Select(op => ((IntData)op.GetVariable(GPOperatorLibrary.MIN_TREE_SIZE).Value).Data).Min();
+      int minTreeSize = allowedFunctions.Select(f => ((IntData)f.GetVariable(GPOperatorLibrary.MIN_TREE_SIZE).Value).Data).Min();
       if (minTreeSize > maxTreeSize)
         maxTreeSize = minTreeSize;
@@ -86 +86 @@
       int treeSize = random.Next(minTreeSize, maxTreeSize + 1);
 
-      IOperator[] possibleOperators = allowedOperators.Where(op => ((IntData)op.GetVariable(GPOperatorLibrary.MIN_TREE_HEIGHT).Value).Data <= treeHeight &&
-        ((IntData)op.GetVariable(GPOperatorLibrary.MIN_TREE_SIZE).Value).Data <= treeSize).ToArray();
-      IOperator selectedOperator = possibleOperators[random.Next(possibleOperators.Length)];
-
-      return CreateRandomTree(selectedOperator, treeSize, treeHeight, balanceTrees);
+      IFunction[] possibleFunctions = allowedFunctions.Where(f => ((IntData)f.GetVariable(GPOperatorLibrary.MIN_TREE_HEIGHT).Value).Data <= treeHeight &&
+        ((IntData)f.GetVariable(GPOperatorLibrary.MIN_TREE_SIZE).Value).Data <= treeSize).ToArray();
+      IFunction selectedFunction = possibleFunctions[random.Next(possibleFunctions.Length)];
+
+      return CreateRandomTree(selectedFunction, treeSize, treeHeight, balanceTrees);
     }
 
@@ -96 +96 @@
       if (balanceTrees) {
         if (maxTreeHeight == 1 || maxTreeSize==1) {
-          IOperator selectedTerminal = terminals[random.Next(terminals.Count())];
+          IFunction selectedTerminal = terminals[random.Next(terminals.Count())];
           return new FunctionTree(selectedTerminal);
         } else {
-          IOperator[] possibleFunctions = functions.Where(f => GetMinimalTreeHeight(f) <= maxTreeHeight &&
+          IFunction[] possibleFunctions = functions.Where(f => GetMinimalTreeHeight(f) <= maxTreeHeight &&
             GetMinimalTreeSize(f) <= maxTreeSize).ToArray();
-          IOperator selectedFunction = possibleFunctions[random.Next(possibleFunctions.Length)];
+          IFunction selectedFunction = possibleFunctions[random.Next(possibleFunctions.Length)];
           FunctionTree root = new FunctionTree(selectedFunction);
           MakeBalancedTree(root, maxTreeSize - 1, maxTreeHeight - 1);
@@ -108 +108 @@
 
       } else {
-        IOperator[] possibleOperators = allOperators.Where(op => GetMinimalTreeHeight(op) <= maxTreeHeight &&
-          GetMinimalTreeSize(op) <= maxTreeSize).ToArray();
-        IOperator selectedOperator = possibleOperators[random.Next(possibleOperators.Length)];
-        FunctionTree root = new FunctionTree(selectedOperator);
+        IFunction[] possibleFunctions = allFunctions.Where(f => GetMinimalTreeHeight(f) <= maxTreeHeight &&
+          GetMinimalTreeSize(f) <= maxTreeSize).ToArray();
+        IFunction selectedFunction = possibleFunctions[random.Next(possibleFunctions.Length)];
+        FunctionTree root = new FunctionTree(selectedFunction);
         MakeUnbalancedTree(root, maxTreeSize - 1, maxTreeHeight - 1);
         return root;
@@ -117 +117 @@
     }
 
-    internal IFunctionTree CreateRandomTree(IOperator rootOp, int maxTreeSize, int maxTreeHeight, bool balanceTrees) {
-      IFunctionTree root = new FunctionTree(rootOp);
+    internal IFunctionTree CreateRandomTree(IFunction rootFunction, int maxTreeSize, int maxTreeHeight, bool balanceTrees) {
+      IFunctionTree root = new FunctionTree(rootFunction);
       if (balanceTrees) {
         MakeBalancedTree(root, maxTreeSize - 1, maxTreeHeight - 1);
@@ -144 +144 @@
         int maxSubTreeSize = maxTreeSize / actualArity;
         for (int i = 0; i < actualArity; i++) {
-          IOperator[] possibleOperators = GetAllowedSubOperators(parent.Function, i).Where(op => GetMinimalTreeHeight(op) <= maxTreeHeight &&
-            GetMinimalTreeSize(op) <= maxSubTreeSize).ToArray();
-          IOperator selectedOperator = possibleOperators[random.Next(possibleOperators.Length)];
-          FunctionTree newSubTree = new FunctionTree(selectedOperator);
+          IFunction[] possibleFunctions = GetAllowedSubFunctions(parent.Function, i).Where(f => GetMinimalTreeHeight(f) <= maxTreeHeight &&
+            GetMinimalTreeSize(f) <= maxSubTreeSize).ToArray();
+          IFunction selectedFunction = possibleFunctions[random.Next(possibleFunctions.Length)];
+          FunctionTree newSubTree = new FunctionTree(selectedFunction);
           MakeUnbalancedTree(newSubTree, maxSubTreeSize - 1, maxTreeHeight - 1);
           parent.InsertSubTree(i, newSubTree);
@@ -155 +155 @@
 
     // NOTE: this method doesn't build fully balanced trees because we have constraints on the
-    // types of possible suboperators which can indirectly impose a limit for the depth of a given suboperator
+    // types of possible sub-functions which can indirectly impose a limit for the depth of a given sub-tree
     private void MakeBalancedTree(IFunctionTree parent, int maxTreeSize, int maxTreeHeight) {
       if (maxTreeHeight == 0 || maxTreeSize == 0) return; // should never happen anyway
@@ -169 +169 @@
         for (int i = 0; i < actualArity; i++) {
           if (maxTreeHeight == 1 || maxSubTreeSize == 1) {
-            IOperator[] possibleTerminals = GetAllowedSubOperators(parent.Function, i).Where(
-              op => GetMinimalTreeHeight(op) <= maxTreeHeight &&
-              GetMinimalTreeSize(op) <= maxSubTreeSize &&
-              IsTerminal(op)).ToArray();
-            IOperator selectedTerminal = possibleTerminals[random.Next(possibleTerminals.Length)];
+            IFunction[] possibleTerminals = GetAllowedSubFunctions(parent.Function, i).Where(
+              f => GetMinimalTreeHeight(f) <= maxTreeHeight &&
+              GetMinimalTreeSize(f) <= maxSubTreeSize &&
+              IsTerminal(f)).ToArray();
+            IFunction selectedTerminal = possibleTerminals[random.Next(possibleTerminals.Length)];
             IFunctionTree newTree = new FunctionTree(selectedTerminal);
             parent.InsertSubTree(i, newTree);
           } else {
-            IOperator[] possibleFunctions = GetAllowedSubOperators(parent.Function, i).Where(
-              op => GetMinimalTreeHeight(op) <= maxTreeHeight &&
-              GetMinimalTreeSize(op) <= maxSubTreeSize &&
-              !IsTerminal(op)).ToArray();
-            IOperator selectedFunction = possibleFunctions[random.Next(possibleFunctions.Length)];
+            IFunction[] possibleFunctions = GetAllowedSubFunctions(parent.Function, i).Where(
+              f => GetMinimalTreeHeight(f) <= maxTreeHeight &&
+              GetMinimalTreeSize(f) <= maxSubTreeSize &&
+              !IsTerminal(f)).ToArray();
+            IFunction selectedFunction = possibleFunctions[random.Next(possibleFunctions.Length)];
             FunctionTree newTree = new FunctionTree(selectedFunction);
             parent.InsertSubTree(i, newTree);
@@ -195 +195 @@
       Scope tempScope = new Scope("Temp. initialization scope");
 
-      var parametricTrees = trees.Where(o => o.Function.GetVariable(GPOperatorLibrary.INITIALIZATION) != null);
+      var parametricTrees = trees.Where(t => t.Function.GetVariable(GPOperatorLibrary.INITIALIZATION) != null);
 
       foreach (IFunctionTree tree in parametricTrees) {
@@ -250 +250 @@
     }
 
-    internal IList<IOperator> GetAllowedSubOperators(IOperator op, int index) {
-      if (op == null) {
-        return allOperators;
+    internal IList<IFunction> GetAllowedSubFunctions(IFunction f, int index) {
+      if (f == null) {
+        return allFunctions;
       } else {
 
         SubOperatorsConstraintAnalyser analyser = new SubOperatorsConstraintAnalyser();
-        analyser.AllPossibleOperators = allOperators;
-
-        return analyser.GetAllowedOperators(op, index);
-      }
-    }
-    internal void GetMinMaxArity(IOperator root, out int minArity, out int maxArity) {
-      foreach (IConstraint constraint in root.Constraints) {
+        analyser.AllPossibleOperators = allFunctions.Cast<IOperator>().ToArray<IOperator>();
+
+        return analyser.GetAllowedOperators(f, index).Cast<IFunction>().ToList<IFunction>();
+      }
+    }
+    internal void GetMinMaxArity(IFunction f, out int minArity, out int maxArity) {
+      foreach (IConstraint constraint in f.Constraints) {
         NumberOfSubOperatorsConstraint theConstraint = constraint as NumberOfSubOperatorsConstraint;
         if (theConstraint != null) {
@@ -274 +274 @@
       maxArity = 2;
     }
-    internal bool IsTerminal(IOperator f) {
+    internal bool IsTerminal(IFunction f) {
       int minArity;
       int maxArity;
@@ -281 +281 @@
     }
 
-    internal IList<IOperator> GetAllowedParents(IOperator child, int childIndex) {
-      List<IOperator> parents = new List<IOperator>();
-      foreach (IOperator function in functions) {
-        IList<IOperator> allowedSubOperators = GetAllowedSubOperators(function, childIndex);
-        if (allowedSubOperators.Contains(child, new OperatorEqualityComparer())) {
+    internal IList<IFunction> GetAllowedParents(IFunction child, int childIndex) {
+      List<IFunction> parents = new List<IFunction>();
+      foreach (IFunction function in functions) {
+        IList<IFunction> allowedSubFunctions = GetAllowedSubFunctions(function, childIndex);
+        if (allowedSubFunctions.Contains(child, new FunctionEqualityComparer())) {
           parents.Add(function);
         }
@@ -292 +292 @@
     }
 
-    internal ICollection<IFunctionTree> GetAllOperators(IFunctionTree root) {
-      List<IFunctionTree> allOps = new List<IFunctionTree>();
-      TreeForEach(root, t => { allOps.Add(t); });
-      return allOps;
+    internal ICollection<IFunctionTree> GetAllSubTrees(IFunctionTree root) {
+      List<IFunctionTree> allTrees = new List<IFunctionTree>();
+      TreeForEach(root, t => { allTrees.Add(t); });
+      return allTrees;
     }
 
     /// <summary>
-    /// returns the height level of op in the tree
-    /// if the op == tree => 1
-    /// if op is in the suboperators of tree => 2
+    /// returns the height level of branch in the tree
+    /// if the branch == tree => 1
+    /// if branch is in the sub-trees of tree => 2
     /// ...
-    /// if op is not found => -1
+    /// if branch is not found => -1
     /// </summary>
-    /// <param name="tree">operator tree to process</param>
-    /// <param name="op">operater that is searched in the tree</param>
+    /// <param name="tree">root of the function tree to process</param>
+    /// <param name="branch">branch that is searched in the tree</param>
     /// <returns></returns>
-    internal int GetNodeLevel(IFunctionTree tree, IFunctionTree op) {
-      return GetNodeLevelHelper(tree, op, 1);
-    }
-
-    private int GetNodeLevelHelper(IFunctionTree tree, IFunctionTree op, int level) {
-      if (op == tree) return level;
+    internal int GetBranchLevel(IFunctionTree tree, IFunctionTree branch) {
+      return GetBranchLevelHelper(tree, branch, 1);
+    }
+
+    // 'tail-recursive' helper
+    private int GetBranchLevelHelper(IFunctionTree tree, IFunctionTree branch, int level) {
+      if (branch == tree) return level;
 
       foreach (IFunctionTree subTree in tree.SubTrees) {
-        int result = GetNodeLevelHelper(subTree, op, level + 1);
+        int result = GetBranchLevelHelper(subTree, branch, level + 1);
         if (result != -1) return result;
       }
@@ -334 +335 @@
     }
 
-    // returns a random node from the specified level in the tree
-    internal IFunctionTree GetRandomNode(IFunctionTree tree, int level) {
+    // returns a random branch from the specified level in the tree
+    internal IFunctionTree GetRandomBranch(IFunctionTree tree, int level) {
       if (level == 0) return tree;
-      List<IFunctionTree> nodes = GetOperatorsAtLevel(tree, level);
-      return nodes[random.Next(nodes.Count)];
+      List<IFunctionTree> branches = GetBranchesAtLevel(tree, level);
+      return branches[random.Next(branches.Count)];
     }
     #endregion
@@ -359 +360 @@
     }
 
-    private List<IFunctionTree> GetOperatorsAtLevel(IFunctionTree tree, int level) {
+    private List<IFunctionTree> GetBranchesAtLevel(IFunctionTree tree, int level) {
       if (level == 1) return new List<IFunctionTree>(tree.SubTrees);
 
-      List<IFunctionTree> result = new List<IFunctionTree>();
+      List<IFunctionTree> branches = new List<IFunctionTree>();
       foreach (IFunctionTree subTree in tree.SubTrees) {
-        result.AddRange(GetOperatorsAtLevel(subTree, level - 1));
-      }
-      return result;
+        branches.AddRange(GetBranchesAtLevel(subTree, level - 1));
+      }
+      return branches;
     }
 
@@ -372 +373 @@
     #endregion
 
-    internal class OperatorEqualityComparer : IEqualityComparer<IOperator> {
-      #region IEqualityComparer<IOperator> Members
-      public bool Equals(IOperator x, IOperator y) {
+    internal class FunctionEqualityComparer : IEqualityComparer<IFunction> {
+      #region IEqualityComparer<IFunction> Members
+      public bool Equals(IFunction x, IFunction y) {
         return  x==y || 
           ((StringData)x.GetVariable(GPOperatorLibrary.TYPE_ID).Value).Data ==
@@ -380 +381 @@
       }
 
-      public int GetHashCode(IOperator obj) {
+      public int GetHashCode(IFunction obj) {
         return ((StringData)obj.GetVariable(GPOperatorLibrary.TYPE_ID).Value).Data.GetHashCode();
       }
@@ -386 +387 @@
     }
 
-    internal ICollection<IOperator> GetPossibleParents(List<IOperator> list) {
-      List<IOperator> result = new List<IOperator>();
-      foreach (IOperator op in functions) {
-        if (IsPossibleParent(op, list)) {
-          result.Add(op);
+    internal ICollection<IFunction> GetPossibleParents(List<IFunction> list) {
+      List<IFunction> result = new List<IFunction>();
+      foreach (IFunction f in functions) {
+        if (IsPossibleParent(f, list)) {
+          result.Add(f);
         }
       }
@@ -396 +397 @@
     }
 
-    private bool IsPossibleParent(IOperator op, List<IOperator> children) {
+    private bool IsPossibleParent(IFunction f, List<IFunction> children) {
       int minArity;
       int maxArity;
-      GetMinMaxArity(op, out minArity, out maxArity);
+      GetMinMaxArity(f, out minArity, out maxArity);
 
       // note: we can't assume that the operators in the children list have different types!
@@ -411 +412 @@
 
       SubOperatorsConstraintAnalyser analyzer = new SubOperatorsConstraintAnalyser();
-      analyzer.AllPossibleOperators = children;
-
-      List<HashSet<IOperator>> slotSets = new List<HashSet<IOperator>>();
-
-      // we iterate through all slots for sub-operators and calculate the set of 
-      // allowed sub-operators for this slot.
+      analyzer.AllPossibleOperators = children.Cast<IOperator>().ToArray<IOperator>();
+
+      List<HashSet<IFunction>> slotSets = new List<HashSet<IFunction>>();
+
+      // we iterate through all slots for sub-trees and calculate the set of 
+      // allowed functions for this slot.
       // we only count those slots that can hold at least one of the children that we should combine
       for (int slot = 0; slot < nSlots; slot++) {
-        HashSet<IOperator> operatorSet = new HashSet<IOperator>(analyzer.GetAllowedOperators(op, slot));
-        if (operatorSet.Count() > 0) {
-          slotSets.Add(operatorSet);
+        HashSet<IFunction> functionSet = new HashSet<IFunction>(analyzer.GetAllowedOperators(f, slot).Cast<IFunction>());
+        if (functionSet.Count() > 0) {
+          slotSets.Add(functionSet);
         }
       }
@@ -428 +429 @@
       // hold one of our children.
       // if the number of slots is smaller than the number of children we can be sure that
-      // we can never combine all children as sub-operators of the operator and thus the operator
+      // we can never combine all children as sub-trees of the function and thus the function
       // can't be a parent.
       if (slotSets.Count() < children.Count()) {
@@ -435 +436 @@
 
       // finally we sort the sets by size and beginning from the first set select one
-      // operator for the slot and thus remove it as possible sub-operator from the remaining sets.
-      // when we can successfully assign all available children to a slot the operator is a valid parent
-      // when only a subset of all children can be assigned to slots the operator is no valid parent
+      // function for the slot and thus remove it as possible sub-tree from the remaining sets.
+      // when we can successfully assign all available children to a slot the function is a valid parent
+      // when only a subset of all children can be assigned to slots the function is no valid parent
       slotSets.Sort((p, q) => p.Count() - q.Count());
 
@@ -443 +444 @@
       for (int i = 0; i < slotSets.Count() - 1; i++) {
         if (slotSets[i].Count > 0) {
-          IOperator selected = slotSets[i].ElementAt(0);
+          IFunction selected = slotSets[i].ElementAt(0);
           assignments++;
           for (int j = i + 1; j < slotSets.Count(); j++) {

branches/FunctionsAndStructIdRefactoring/HeuristicLab/UpdateLocalInstallation.cmd

@@ -1 @@
-set target=G:\Program Files\HeuristicLab 3.0
+set target=C:\Program Files\HeuristicLab 3.0
 
 copy "HeuristicLab.exe" "%target%"