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

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

File:

• branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/Manipulation/CutOutNodeManipulation.cs (modified) (4 diffs)

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);
       }
     }