Changeset 5510 for branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentCreater.cs

Timestamp:

02/17/11 13:51:04 (13 years ago)

Author:

gkronber

Message:

#1418 Fixed compiler errors in symbolic expression tree encoding

File:

• branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentCreater.cs (modified) (8 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentCreater.cs

@@ -27 +27 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -33 +34 @@
   /// As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 106
   /// </summary>
-  [Item("ArgumentCreater", "Manipulates a symbolic expression by creating a new argument within one function-defining branch.")]
+  [Item("ArgumentCreater", "Manipulates a symbolic expression by creating a new argument within one function-defining branch. As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 106")]
   [StorableClass]
-  public sealed class ArgumentCreater : SymbolicExpressionTreeArchitectureManipulator {
+  public sealed class ArgumentCreater : SymbolicExpressionTreeArchitectureManipulator, ISymbolicExpressionTreeSizeConstraintOperator {
+    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
+    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
+    #region Parameter Properties
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
+    }
+    #endregion
+    #region Properties
+    public IntValue MaximumSymbolicExpressionTreeLength {
+      get { return MaximumSymbolicExpressionTreeLengthParameter.ActualValue; }
+    }
+    public IntValue MaximumSymbolicExpressionTreeDepth {
+      get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; }
+    }
+    #endregion
     [StorableConstructor]
     private ArgumentCreater(bool deserializing) : base(deserializing) { }
     private ArgumentCreater(ArgumentCreater original, Cloner cloner) : base(original, cloner) { }
-    public ArgumentCreater() : base() { }
+    public ArgumentCreater()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "The maximal length (number of nodes) of the symbolic expression tree."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
+    }
+
     public override sealed void ModifyArchitecture(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      IntValue maxTreeSize, IntValue maxTreeHeight,
-      IntValue maxFunctionDefiningBranches, IntValue maxFunctionArguments,
-      out bool success) {
-      success = CreateNewArgument(random, symbolicExpressionTree, grammar, maxTreeSize.Value, maxTreeHeight.Value, maxFunctionDefiningBranches.Value, maxFunctionArguments.Value);
+      ISymbolicExpressionTree symbolicExpressionTree,
+      IntValue maxFunctionDefinitions, IntValue maxFunctionArguments) {
+      CreateNewArgument(random, symbolicExpressionTree, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value, maxFunctionDefinitions.Value, maxFunctionArguments.Value);
     }
 
@@ -56 +77 @@
     public static bool CreateNewArgument(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      int maxTreeSize, int maxTreeHeight,
-      int maxFunctionDefiningBranches, int maxFunctionArguments) {
+      ISymbolicExpressionTree symbolicExpressionTree,
+      int maxTreeLength, int maxTreeDepth,
+      int maxFunctionDefinitions, int maxFunctionArguments) {
       // work on a copy in case we find out later that the tree would be too big
       // in this case it's easiest to simply return the original tree.
-      SymbolicExpressionTree clonedTree = (SymbolicExpressionTree)symbolicExpressionTree.Clone();
+      ISymbolicExpressionTree clonedTree = (ISymbolicExpressionTree)symbolicExpressionTree.Clone();
 
       var functionDefiningBranches = clonedTree.IterateNodesPrefix().OfType<DefunTreeNode>();
@@ -83 +103 @@
       // this operation potentially creates very big trees so the access to the size property might throw overflow exception
       try {
-        if (CreateNewArgumentForDefun(random, clonedTree, selectedDefunBranch, newArgumentNode) && clonedTree.Size <= maxTreeSize && clonedTree.Height <= maxTreeHeight) {
+        if (CreateNewArgumentForDefun(random, clonedTree, selectedDefunBranch, newArgumentNode) && clonedTree.Size <= maxTreeLength && clonedTree.Height <= maxTreeDepth) {
 
           // size constraints are fulfilled 
@@ -100 +120 @@
     }
 
-    private static bool CreateNewArgumentForDefun(IRandom random, SymbolicExpressionTree tree, DefunTreeNode defunBranch, ArgumentTreeNode newArgumentNode) {
+    private static bool CreateNewArgumentForDefun(IRandom random, ISymbolicExpressionTree tree, DefunTreeNode defunBranch, ArgumentTreeNode newArgumentNode) {
       // select a random cut point in the function defining branch
       // the branch at the cut point is to be replaced by a new argument node
       var cutPoints = (from node in defunBranch.IterateNodesPrefix()
-                       where node.SubTrees.Count > 0
+                       where node.SubTrees.Count() > 0
                        from subtree in node.SubTrees
-                       select new { Parent = node, ReplacedChildIndex = node.SubTrees.IndexOf(subtree), ReplacedChild = subtree }).ToList();
+                       select new { Parent = node, ReplacedChildIndex = node.IndexOfSubTree(subtree), ReplacedChild = subtree }).ToList();
 
       if (cutPoints.Count() == 0)
@@ -121 +141 @@
       var invocationNodes = (from node in tree.IterateNodesPostfix().OfType<InvokeFunctionTreeNode>()
                              where node.Symbol.FunctionName == defunBranch.FunctionName
-                             where node.SubTrees.Count == defunBranch.NumberOfArguments
+                             where node.SubTrees.Count() == defunBranch.NumberOfArguments
                              select node).ToList();
       // do this repeatedly until no matching invocations are found      
       while (invocationNodes.Count > 0) {
-        List<SymbolicExpressionTreeNode> newlyAddedBranches = new List<SymbolicExpressionTreeNode>();
+        List<ISymbolicExpressionTreeNode> newlyAddedBranches = new List<ISymbolicExpressionTreeNode>();
         foreach (var invocationNode in invocationNodes) {
           // check that the invocation node really has the correct number of arguments
-          if (invocationNode.SubTrees.Count != defunBranch.NumberOfArguments) throw new InvalidOperationException();
+          if (invocationNode.SubTrees.Count() != defunBranch.NumberOfArguments) throw new InvalidOperationException();
           // append a new argument branch after expanding all argument nodes
-          var clonedBranch = (SymbolicExpressionTreeNode)replacedBranch.Clone();
+          var clonedBranch = (ISymbolicExpressionTreeNode)replacedBranch.Clone();
           clonedBranch = ReplaceArgumentsInBranch(clonedBranch, invocationNode.SubTrees);
           invocationNode.InsertSubTree(newArgumentNode.Symbol.ArgumentIndex, clonedBranch);
@@ -139 +159 @@
                            from node in newlyAddedBranch.IterateNodesPostfix().OfType<InvokeFunctionTreeNode>()
                            where node.Symbol.FunctionName == defunBranch.FunctionName
-                           where node.SubTrees.Count == defunBranch.NumberOfArguments
+                           where node.SubTrees.Count() == defunBranch.NumberOfArguments
                            select node).ToList();
       }
@@ -171 +191 @@
     }
 
-    private static SymbolicExpressionTreeNode ReplaceArgumentsInBranch(SymbolicExpressionTreeNode branch, IList<SymbolicExpressionTreeNode> argumentTrees) {
+    private static ISymbolicExpressionTreeNode ReplaceArgumentsInBranch(ISymbolicExpressionTreeNode branch, IEnumerable<ISymbolicExpressionTreeNode> argumentTrees) {
       ArgumentTreeNode argNode = branch as ArgumentTreeNode;
       if (argNode != null) {
         // replace argument nodes by a clone of the original subtree that provided the result for the argument node
-        return (SymbolicExpressionTreeNode)argumentTrees[argNode.Symbol.ArgumentIndex].Clone();
+        return (SymbolicExpressionTreeNode)argumentTrees.ElementAt(argNode.Symbol.ArgumentIndex).Clone();
       } else {
         // call recursively for all subtree
-        List<SymbolicExpressionTreeNode> subtrees = new List<SymbolicExpressionTreeNode>(branch.SubTrees);
-        while (branch.SubTrees.Count > 0) branch.RemoveSubTree(0);
+        List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(branch.SubTrees);
+        while (branch.SubTrees.Count() > 0) branch.RemoveSubTree(0);
         foreach (var subtree in subtrees) {
           branch.AddSubTree(ReplaceArgumentsInBranch(subtree, argumentTrees));