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

Timestamp:

07/28/09 19:24:23 (15 years ago)

Author:

gkronber

Message:

Created a branch for #713

Location:

branches/GP-Refactoring-713

Files:

• . (copied) (copied from trunk)
• sources/HeuristicLab.GP/3.3/TreeGardener.cs (modified) (17 diffs)

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

@@ -36 +36 @@
   internal class TreeGardener {
     private IRandom random;
-    private GPOperatorLibrary funLibrary;
+    private FunctionLibrary funLibrary;
     private List<IFunction> functions;
 
@@ -50 +50 @@
 
     #region constructors
-    internal TreeGardener(IRandom random, GPOperatorLibrary funLibrary) {
+    internal TreeGardener(IRandom random, FunctionLibrary funLibrary) {
       this.random = random;
       this.funLibrary = funLibrary;
@@ -57 +57 @@
       functions = new List<IFunction>();
       // init functions and terminals based on constraints
-      foreach(IFunction fun in funLibrary.Group.Operators) {
+      foreach(IFunction fun in funLibrary.Functions) {
         if(fun.MaxArity == 0) {
           terminals.Add(fun);
@@ -112 +112 @@
       }
       int actualArity = random.Next(minArity, maxArity + 1);
-      totalListMinSize += GetMinimalTreeSize(root.Function) - 1;
+      totalListMinSize += root.Function.MinTreeSize - 1;
       for(int i = 0; i < actualArity; i++) {
         // insert a dummy sub-tree and add the pending extension to the list
@@ -134 +134 @@
         } else {
           IFunction selectedFunction = RandomSelect(GetAllowedSubFunctions(parent.Function, a).Where(
-            f => !IsTerminal(f) && GetMinimalTreeHeight(f) + (d - 1) <= maxDepth).ToArray());
+            f => !IsTerminal(f) && f.MinTreeHeight + (d - 1) <= maxDepth).ToArray());
           IFunctionTree newTree = selectedFunction.GetTreeNode();
           parent.RemoveSubTree(a);
@@ -152 +152 @@
             list.Add(new object[] { newTree, i, d + 1 });
           }
-          totalListMinSize += GetMinimalTreeSize(newTree.Function) - 1;
+          totalListMinSize += newTree.Function.MinTreeSize - 1;
         }
       }
@@ -178 +178 @@
     internal IFunctionTree CreateRandomTree(ICollection<IFunction> allowedFunctions, int maxTreeSize, int maxTreeHeight) {
       // get the minimal needed height based on allowed functions and extend the max-height if necessary
-      int minTreeHeight = allowedFunctions.Select(f => GetMinimalTreeHeight(f)).Min();
+      int minTreeHeight = allowedFunctions.Select(f => f.MinTreeHeight).Min();
       if(minTreeHeight > maxTreeHeight)
         maxTreeHeight = minTreeHeight;
       // get the minimal needed size based on allowed functions and extend the max-size if necessary
-      int minTreeSize = allowedFunctions.Select(f => GetMinimalTreeSize(f)).Min();
+      int minTreeSize = allowedFunctions.Select(f => f.MinTreeSize).Min();
       if(minTreeSize > maxTreeSize)
         maxTreeSize = minTreeSize;
@@ -191 +191 @@
 
       // filter the set of allowed functions and select only from those that fit into the given maximal size and height limits
-      IFunction[] possibleFunctions = allowedFunctions.Where(f => GetMinimalTreeHeight(f) <= treeHeight &&
-        GetMinimalTreeSize(f) <= treeSize).ToArray();
+      IFunction[] possibleFunctions = allowedFunctions.Where(f => f.MinTreeHeight <= treeHeight &&
+        f.MinTreeSize <= treeSize).ToArray();
       IFunction selectedFunction = RandomSelect(possibleFunctions);
 
@@ -206 +206 @@
       Scope tempScope = new Scope("Temp. initialization scope");
 
-      var parametricTrees = trees.Where(t => t.Function.GetVariable(FunctionBase.INITIALIZATION) != null);
+      var parametricTrees = trees.Where(t => t.Initializer != null);
       foreach(IFunctionTree tree in parametricTrees) {
         // enqueue an initialization operation for each operator with local variables 
-        IOperator initialization = (IOperator)tree.Function.GetVariable(FunctionBase.INITIALIZATION).Value;
+        IOperator initialization = tree.Initializer;
         Scope initScope = new Scope();
         // copy the local variables into a temporary scope used for initialization
@@ -280 +280 @@
     internal bool IsValidTree(IFunctionTree tree) {
       for(int i = 0; i < tree.SubTrees.Count; i++) {
-        if(!tree.Function.AllowedSubFunctions(i).Contains(tree.SubTrees[i].Function)) return false;
+        if(!tree.Function.GetAllowedSubFunctions(i).Contains(tree.SubTrees[i].Function)) return false;
       }
 
@@ -329 +329 @@
       // 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<IFunction> functionSet = new HashSet<IFunction>(f.AllowedSubFunctions(slot));
+        HashSet<IFunction> functionSet = new HashSet<IFunction>(f.GetAllowedSubFunctions(slot));
         if(functionSet.Count() > 0) {
           slotSets.Add(functionSet);
@@ -378 +378 @@
       return f.MinArity == 0 && f.MaxArity == 0;
     }
-    internal IList<IFunction> GetAllowedSubFunctions(IFunction f, int index) {
+    internal ICollection<IFunction> GetAllowedSubFunctions(IFunction f, int index) {
       if(f == null) {
         return allFunctions;
       } else {
-        return f.AllowedSubFunctions(index);
+        return f.GetAllowedSubFunctions(index);
       }
     }
@@ -393 +393 @@
         return selectedTerminal;
       } else {
-        IFunction[] possibleFunctions = functions.Where(f => GetMinimalTreeHeight(f) <= maxTreeHeight &&
-          GetMinimalTreeSize(f) <= maxTreeSize).ToArray();
+        IFunction[] possibleFunctions = functions.Where(f => f.MinTreeHeight <= maxTreeHeight &&
+          f.MinTreeSize <= maxTreeSize).ToArray();
         IFunction selectedFunction = RandomSelect(possibleFunctions);
         return selectedFunction;
@@ -409 +409 @@
         IFunctionTree parentTree = parent.GetTreeNode();
         for(int i = 0; i < actualArity; i++) {
-          IFunction[] possibleFunctions = GetAllowedSubFunctions(parent, i).Where(f => GetMinimalTreeHeight(f) <= maxTreeHeight).ToArray();
+          IFunction[] possibleFunctions = GetAllowedSubFunctions(parent, i).Where(f => f.MinTreeHeight <= maxTreeHeight).ToArray();
           IFunction selectedFunction = RandomSelect(possibleFunctions);
           IFunctionTree newSubTree = MakeUnbalancedTree(selectedFunction, maxTreeHeight - 1);
@@ -431 +431 @@
         for(int i = 0; i < actualArity; i++) {
           // first try to find a function that fits into the maxHeight limit
-          IFunction[] possibleFunctions = GetAllowedSubFunctions(parent, i).Where(f => GetMinimalTreeHeight(f) <= maxTreeHeight &&
+          IFunction[] possibleFunctions = GetAllowedSubFunctions(parent, i).Where(f => f.MinTreeHeight <= maxTreeHeight &&
             !IsTerminal(f)).ToArray();
           // no possible function found => extend function set to terminals
@@ -450 +450 @@
     }
 
-    private int GetMinimalTreeHeight(IOperator op) {
-      return ((IntData)op.GetVariable(GPOperatorLibrary.MIN_TREE_HEIGHT).Value).Data;
-    }
-
-    private int GetMinimalTreeSize(IOperator op) {
-      return ((IntData)op.GetVariable(GPOperatorLibrary.MIN_TREE_SIZE).Value).Data;
-    }
-
     private void TreeForEach(IFunctionTree tree, Action<IFunctionTree> action) {
       action(tree);
@@ -479 +471 @@
       // precalculate the slot-sizes
       foreach(IFunction function in functionSet) {
-        ticketAccumulator += ((DoubleData)function.GetVariable(GPOperatorLibrary.TICKETS).Value).Data;
+        ticketAccumulator += function.Tickets;
         accumulatedTickets[i] = ticketAccumulator;
         i++;