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

Timestamp:

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

Author:

gkronber

Message:

#1418 Fixed compiler errors in symbolic expression tree encoding

Location:

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

Files:

• ArgumentCreater.cs (modified) (8 diffs)
• ArgumentDeleter.cs (modified) (3 diffs)
• ArgumentDuplicater.cs (modified) (5 diffs)
• MultiSymbolicExpressionTreeArchitectureManipulator.cs (modified) (4 diffs)
• SubroutineCreater.cs (modified) (12 diffs)
• SubroutineDeleter.cs (modified) (6 diffs)
• SubroutineDuplicater.cs (modified) (4 diffs)
• SymbolicExpressionTreeArchitectureManipulator.cs (modified) (2 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));

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

@@ -30 +30 @@
   /// As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 112
   /// </summary>
-  [Item("ArgumentDeleter", "Manipulates a symbolic expression by deleting an argument from an existing function defining branch.")]
+  [Item("ArgumentDeleter", "Manipulates a symbolic expression by deleting an argument from an existing function defining branch. As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 112")]
   [StorableClass]
   public sealed class ArgumentDeleter : SymbolicExpressionTreeArchitectureManipulator {
@@ -40 +40 @@
     public override sealed void ModifyArchitecture(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      IntValue maxTreeSize, IntValue maxTreeHeight,
-      IntValue maxFunctionDefiningBranches, IntValue maxFunctionArguments,
-      out bool success) {
-      success = DeleteArgument(random, symbolicExpressionTree, grammar, maxTreeSize.Value, maxTreeHeight.Value, maxFunctionDefiningBranches.Value, maxFunctionArguments.Value);
+      ISymbolicExpressionTree symbolicExpressionTree,
+      IntValue maxFunctionDefinitions, IntValue maxFunctionArguments) {
+      DeleteArgument(random, symbolicExpressionTree, maxFunctionDefinitions.Value, maxFunctionArguments.Value);
     }
 
@@ -54 +51 @@
     public static bool DeleteArgument(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      int maxTreeSize, int maxTreeHeight,
-      int maxFunctionDefiningBranches, int maxFunctionArguments) {
+      ISymbolicExpressionTree symbolicExpressionTree,
+      int maxFunctionDefinitions, int maxFunctionArguments) {
 
       var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();

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

@@ -33 +33 @@
   /// As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 94
   /// </summary>
-  [Item("ArgumentDuplicater", "Manipulates a symbolic expression by duplicating an existing argument node of a function-defining branch.")]
+  [Item("ArgumentDuplicater", "Manipulates a symbolic expression by duplicating an existing argument node of a function-defining branch. As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 94")]
   [StorableClass]
   public sealed class ArgumentDuplicater : SymbolicExpressionTreeArchitectureManipulator {
@@ -43 +43 @@
     public override sealed void ModifyArchitecture(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      IntValue maxTreeSize, IntValue maxTreeHeight,
-      IntValue maxFunctionDefiningBranches, IntValue maxFunctionArguments,
-      out bool success) {
-      success = DuplicateArgument(random, symbolicExpressionTree, grammar, maxTreeSize.Value, maxTreeHeight.Value, maxFunctionDefiningBranches.Value, maxFunctionArguments.Value);
+      ISymbolicExpressionTree symbolicExpressionTree,
+      IntValue maxFunctionDefinitions, IntValue maxFunctionArguments) {
+      DuplicateArgument(random, symbolicExpressionTree, maxFunctionDefinitions.Value, maxFunctionArguments.Value);
     }
 
@@ -57 +54 @@
     public static bool DuplicateArgument(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      int maxTreeSize, int maxTreeHeight,
-      int maxFunctionDefiningBranches, int maxFunctionArguments) {
+      ISymbolicExpressionTree symbolicExpressionTree,
+      int maxFunctionDefinitions, int maxFunctionArguments) {
       var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();
 
@@ -91 +86 @@
       var invocationNodes = (from node in symbolicExpressionTree.IterateNodesPrefix().OfType<InvokeFunctionTreeNode>()
                              where node.Symbol.FunctionName == selectedDefunBranch.FunctionName
-                             where node.SubTrees.Count == selectedDefunBranch.NumberOfArguments
+                             where node.SubTrees.Count() == selectedDefunBranch.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 invokeNode in invocationNodes) {
           // check that the invocation node really has the correct number of arguments
-          if (invokeNode.SubTrees.Count != selectedDefunBranch.NumberOfArguments) throw new InvalidOperationException();
-          var argumentBranch = invokeNode.SubTrees[selectedArgumentSymbol.ArgumentIndex];
-          var clonedArgumentBranch = (SymbolicExpressionTreeNode)argumentBranch.Clone();
+          if (invokeNode.SubTrees.Count() != selectedDefunBranch.NumberOfArguments) throw new InvalidOperationException();
+          var argumentBranch = invokeNode.GetSubTree(selectedArgumentSymbol.ArgumentIndex);
+          var clonedArgumentBranch = (ISymbolicExpressionTreeNode)argumentBranch.Clone();
           invokeNode.InsertSubTree(newArgumentIndex, clonedArgumentBranch);
           newlyAddedBranches.Add(clonedArgumentBranch);
@@ -107 +102 @@
                            from node in newlyAddedBranch.IterateNodesPrefix().OfType<InvokeFunctionTreeNode>()
                            where node.Symbol.FunctionName == selectedDefunBranch.FunctionName
-                           where node.SubTrees.Count == selectedDefunBranch.NumberOfArguments
+                           where node.SubTrees.Count() == selectedDefunBranch.NumberOfArguments
                            select node).ToList();
       }

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

@@ -35 +35 @@
   [Item("MultiSymbolicExpressionTreeArchitectureManipulator", "Randomly selects and applies one of its architecture manipulators every time it is called.")]
   [StorableClass]
-  public sealed class MultiSymbolicExpressionTreeArchitectureManipulator : StochasticMultiBranch<ISymbolicExpressionTreeArchitectureManipulator>, ISymbolicExpressionTreeArchitectureManipulator, IStochasticOperator {
-    private const string MaxTreeSizeParameterName = "MaxTreeSize";
-    private const string MaxTreeHeightParameterName = "MaxTreeHeight";
-    private const string SymbolicExpressionGrammarParameterName = "SymbolicExpressionGrammar";
+  public sealed class MultiSymbolicExpressionTreeArchitectureManipulator : StochasticMultiBranch<ISymbolicExpressionTreeArchitectureManipulator>, 
+    ISymbolicExpressionTreeArchitectureManipulator, 
+    ISymbolicExpressionTreeSizeConstraintOperator,
+    IStochasticOperator {
+    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
+    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
     private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
-    private const string MaxFunctionArgumentsParameterName = "MaxFunctionArguments";
-    private const string MaxFunctionDefiningBranchesParameterName = "MaxFunctionDefiningBranches";
+    private const string MaximumFunctionArgumentsParameterName = "MaximumFunctionArguments";
+    private const string MaximumFunctionDefinitionsParameterName = "MaximumFunctionDefinitions";
 
     public override bool CanChangeName {
@@ -49 +51 @@
       get { return true; }
     }
-    #region ISymbolicExpressionTreeArchitectureManipulator Members
-    public IValueLookupParameter<IntValue> MaxFunctionDefinitionsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaxFunctionDefiningBranchesParameterName]; }
+    #region Parameter properties
+    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
     }
-    public IValueLookupParameter<IntValue> MaxFunctionArgumentsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaxFunctionArgumentsParameterName]; }
+    public IValueLookupParameter<IntValue> MaximumFunctionDefinitionsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumFunctionDefinitionsParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumFunctionArgumentsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumFunctionArgumentsParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
     }
     #endregion
-
-    #region ISymbolicExpressionTreeManipulator Members
-    public ILookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
-      get { return (ILookupParameter<SymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    #region Parameter Properties
+    public IntValue MaximumFunctionDefinitions {
+      get { return MaximumFunctionDefinitionsParameter.ActualValue; }
     }
-    #endregion
-
-    #region ISymbolicExpressionTreeOperator Members
-    public IValueLookupParameter<IntValue> MaxTreeSizeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaxTreeSizeParameterName]; }
+    public IntValue MaximumFunctionArguments {
+      get { return MaximumFunctionArgumentsParameter.ActualValue; }
     }
-    public IValueLookupParameter<IntValue> MaxTreeHeightParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaxTreeHeightParameterName]; }
+    public IntValue MaximumSymbolicExpressionTreeLength {
+      get { return MaximumSymbolicExpressionTreeLengthParameter.ActualValue; }
     }
-    public ILookupParameter<ISymbolicExpressionGrammar> SymbolicExpressionGrammarParameter {
-      get { return (ILookupParameter<ISymbolicExpressionGrammar>)Parameters[SymbolicExpressionGrammarParameterName]; }
+    public IntValue MaximumSymbolicExpressionTreeDepth {
+      get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; }
     }
     #endregion
@@ -82 +89 @@
     public MultiSymbolicExpressionTreeArchitectureManipulator()
       : base() {
-      Parameters.Add(new LookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree on which the operator should be applied."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaxFunctionDefiningBranchesParameterName, "The maximal allowed number of function defining branches."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaxFunctionArgumentsParameterName, "The maximal allowed number of arguments of a newly created function."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaxTreeSizeParameterName, "The maximal size (number of nodes) of the symbolic expression tree."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaxTreeHeightParameterName, "The maximal height of the symbolic expression tree (a tree with one node has height = 0)."));
-      Parameters.Add(new LookupParameter<ISymbolicExpressionGrammar>(SymbolicExpressionGrammarParameterName, "The grammar that defines the allowed symbols and syntax of the symbolic expression trees."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree on which the operator should be applied."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumFunctionDefinitionsParameterName, "The maximal allowed number of automatically defined functions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumFunctionArgumentsParameterName, "The maximal allowed number of arguments of a automatically defined functions."));
+      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)."));
 
       foreach (Type type in ApplicationManager.Manager.GetTypes(typeof(ISymbolicExpressionTreeArchitectureManipulator))) {
@@ -111 +117 @@
     private void ParameterizeManipulators() {
       foreach (ISymbolicExpressionTreeArchitectureManipulator manipulator in Operators.OfType<ISymbolicExpressionTreeArchitectureManipulator>()) {
-        manipulator.MaxTreeSizeParameter.ActualName = MaxTreeSizeParameter.Name;
-        manipulator.MaxTreeHeightParameter.ActualName = MaxTreeHeightParameter.Name;
-        manipulator.SymbolicExpressionGrammarParameter.ActualName = SymbolicExpressionGrammarParameter.Name;
+        manipulator.MaximumFunctionArgumentsParameter.ActualName = MaximumFunctionArgumentsParameter.Name;
+        manipulator.MaximumFunctionDefinitionsParameter.ActualName = MaximumFunctionDefinitionsParameter.Name;
+      }
+      foreach(ISymbolicExpressionTreeSizeConstraintOperator manipulator in Operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>()) {
+        manipulator.MaximumSymbolicExpressionTreeDepthParameter.ActualName = MaximumSymbolicExpressionTreeDepthParameter.Name;
+        manipulator.MaximumSymbolicExpressionTreeLengthParameter.ActualName = MaximumSymbolicExpressionTreeLengthParameter.Name;
+      }
+      foreach(ISymbolicExpressionTreeManipulator manipulator in Operators.OfType<ISymbolicExpressionTreeManipulator>()) {
         manipulator.SymbolicExpressionTreeParameter.ActualName = SymbolicExpressionTreeParameter.Name;
-        manipulator.MaxFunctionDefinitionsParameter.ActualName = MaxFunctionDefinitionsParameter.Name;
-        manipulator.MaxFunctionArgumentsParameter.ActualName = MaxFunctionArgumentsParameter.Name;
       }
-
       foreach (IStochasticOperator manipulator in Operators.OfType<IStochasticOperator>()) {
         manipulator.RandomParameter.ActualName = RandomParameter.Name;
       }
     }
-
-    #region ISymbolicExpressionTreeArchitectureManipulator Members
-    public void ModifyArchitecture(IRandom random, SymbolicExpressionTree symbolicExpressionTree, ISymbolicExpressionGrammar grammar, IntValue maxTreeSize, IntValue maxTreeHeight, IntValue maxFunctionDefiningBranches, IntValue maxFunctionArguments, out bool success) {
-      var op = Operators.SelectRandom(random);
-      op.ModifyArchitecture(random, symbolicExpressionTree, grammar, maxTreeSize, maxTreeHeight, maxFunctionDefiningBranches, maxFunctionArguments, out success);
-    }
-    #endregion
   }
 }

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

@@ -28 +28 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -35 +36 @@
   /// As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 97
   /// </summary>
-  [Item("SubroutineCreater", "Manipulates a symbolic expression by adding one new function-defining branch containing a proportion of a preexisting branch and by creating a reference to the new branch.")]
+  [Item("SubroutineCreater", "Manipulates a symbolic expression by adding one new function-defining branch containing a proportion of a preexisting branch and by creating a reference to the new branch. As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 97")]
   [StorableClass]
-  public sealed class SubroutineCreater : SymbolicExpressionTreeArchitectureManipulator {
+  public sealed class SubroutineCreater : SymbolicExpressionTreeArchitectureManipulator, ISymbolicExpressionTreeSizeConstraintOperator {
     private const double ARGUMENT_CUTOFF_PROBABILITY = 0.05;
-
+    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 SubroutineCreater(bool deserializing) : base(deserializing) { }
     private SubroutineCreater(SubroutineCreater original, Cloner cloner) : base(original, cloner) { }
-    public SubroutineCreater() : base() { }
+    public SubroutineCreater() : 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 IDeepCloneable Clone(Cloner cloner) {
@@ -51 +72 @@
     public override sealed void ModifyArchitecture(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      IntValue maxTreeSize, IntValue maxTreeHeight,
-      IntValue maxFunctionDefiningBranches, IntValue maxFunctionArguments,
-      out bool success) {
-      success = CreateSubroutine(random, symbolicExpressionTree, grammar, maxTreeSize.Value, maxTreeHeight.Value, maxFunctionDefiningBranches.Value, maxFunctionArguments.Value);
+      ISymbolicExpressionTree symbolicExpressionTree,
+      IntValue maxFunctionDefinitions, IntValue maxFunctionArguments) {
+      CreateSubroutine(random, symbolicExpressionTree, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value, maxFunctionDefinitions.Value, maxFunctionArguments.Value);
     }
 
     public static bool CreateSubroutine(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      int maxTreeSize, int maxTreeHeight,
-      int maxFunctionDefiningBranches, int maxFunctionArguments) {
+      ISymbolicExpressionTree symbolicExpressionTree,
+      int maxTreeLength, int maxTreeDepth,
+      int maxFunctionDefinitions, int maxFunctionArguments) {
       var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();
-      if (functionDefiningBranches.Count() >= maxFunctionDefiningBranches)
+      if (functionDefiningBranches.Count() >= maxFunctionDefinitions)
         // allowed maximum number of ADF reached => abort
         return false;
-      if (symbolicExpressionTree.Size + 4 > maxTreeSize)
+      if (symbolicExpressionTree.Size + 4 > maxTreeLength)
         // defining a new function causes an size increase by 4 nodes (max) if the max tree size is reached => abort
         return false;
-      string formatString = new StringBuilder().Append('0', (int)Math.Log10(maxFunctionDefiningBranches * 10 - 1)).ToString(); // >= 100 functions => ###
-      var allowedFunctionNames = from index in Enumerable.Range(0, maxFunctionDefiningBranches)
+      string formatString = new StringBuilder().Append('0', (int)Math.Log10(maxFunctionDefinitions * 10 - 1)).ToString(); // >= 100 functions => ###
+      var allowedFunctionNames = from index in Enumerable.Range(0, maxFunctionDefinitions)
                                  select "ADF" + index.ToString(formatString);
 
@@ -82 +99 @@
       int r = random.Next(totalNumberOfBodyNodes);
       int aggregatedNumberOfBodyNodes = 0;
-      SymbolicExpressionTreeNode selectedBody = null;
+      ISymbolicExpressionTreeNode selectedBody = null;
       foreach (var body in bodies) {
         aggregatedNumberOfBodyNodes += body.Size;
@@ -94 +111 @@
       var allCutPoints = from parent in selectedBody.IterateNodesPrefix()
                          from subtree in parent.SubTrees
-                         select new { Parent = parent, ReplacedBranchIndex = parent.SubTrees.IndexOf(subtree), ReplacedBranch = subtree };
+                         select new { Parent = parent, ReplacedBranchIndex = parent.IndexOfSubTree(subtree), ReplacedBranch = subtree };
       if (allCutPoints.Count() == 0)
         // no cut points => abort
@@ -101 +118 @@
       var selectedCutPoint = allCutPoints.SelectRandom(random);
       // select random branches as argument cut-off points (replaced by argument terminal nodes in the function)
-      List<SymbolicExpressionTreeNode> argumentBranches = SelectRandomArgumentBranches(selectedCutPoint.ReplacedBranch, random, ARGUMENT_CUTOFF_PROBABILITY, maxFunctionArguments);
-      SymbolicExpressionTreeNode functionBody = selectedCutPoint.ReplacedBranch;
+      List<ISymbolicExpressionTreeNode> argumentBranches = SelectRandomArgumentBranches(selectedCutPoint.ReplacedBranch, random, ARGUMENT_CUTOFF_PROBABILITY, maxFunctionArguments);
+      ISymbolicExpressionTreeNode functionBody = selectedCutPoint.ReplacedBranch;
       // disconnect the function body from the tree
       selectedCutPoint.Parent.RemoveSubTree(selectedCutPoint.ReplacedBranchIndex);
@@ -120 +137 @@
       symbolicExpressionTree.Root.AddSubTree(defunNode);
       // the grammar in the newly defined function is a clone of the grammar of the originating branch
-      defunNode.SetGrammar((ISymbolicExpressionGrammar)selectedBody.Grammar.Clone());
+      defunNode.SetGrammar((ISymbolicExpressionTreeGrammar)selectedBody.Grammar.Clone());
       // remove all argument symbols from grammar
       var oldArgumentSymbols = defunNode.Grammar.Symbols.OfType<Argument>().ToList();
@@ -164 +181 @@
     }
 
-    private static SymbolicExpressionTreeNode DisconnectBranches(SymbolicExpressionTreeNode node, List<SymbolicExpressionTreeNode> argumentBranches) {
+    private static ISymbolicExpressionTreeNode DisconnectBranches(ISymbolicExpressionTreeNode node, List<ISymbolicExpressionTreeNode> argumentBranches) {
       if (argumentBranches.Contains(node)) {
         var argumentIndex = argumentBranches.IndexOf(node);
@@ -171 +188 @@
       }
       // remove the subtrees so that we can clone only the root node
-      List<SymbolicExpressionTreeNode> subtrees = new List<SymbolicExpressionTreeNode>(node.SubTrees);
-      while (node.SubTrees.Count > 0) node.RemoveSubTree(0);
+      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.SubTrees);
+      while (node.SubTrees.Count() > 0) node.RemoveSubTree(0);
       // recursively apply function for subtrees or append a argument terminal node
       foreach (var subtree in subtrees) {
@@ -180 +197 @@
     }
 
-    private static List<SymbolicExpressionTreeNode> SelectRandomArgumentBranches(SymbolicExpressionTreeNode selectedRoot,
+    private static List<ISymbolicExpressionTreeNode> SelectRandomArgumentBranches(ISymbolicExpressionTreeNode selectedRoot,
       IRandom random,
       double cutProbability,
@@ -186 +203 @@
       // breadth first determination of argument cut-off points
       // we must make sure that we cut off all original argument nodes and that the number of new argument is smaller than the limit
-      List<SymbolicExpressionTreeNode> argumentBranches = new List<SymbolicExpressionTreeNode>();
+      List<ISymbolicExpressionTreeNode> argumentBranches = new List<ISymbolicExpressionTreeNode>();
       if (selectedRoot is ArgumentTreeNode) {
         argumentBranches.Add(selectedRoot);
@@ -202 +219 @@
         }
         // cut-off in the sub-trees in random order
-        var randomIndexes = (from index in Enumerable.Range(0, selectedRoot.SubTrees.Count)
+        var randomIndexes = (from index in Enumerable.Range(0, selectedRoot.SubTrees.Count())
                              select new { Index = index, OrderValue = random.NextDouble() }).OrderBy(x => x.OrderValue).Select(x => x.Index);
         foreach (var subtreeIndex in randomIndexes) {
-          var subtree = selectedRoot.SubTrees[subtreeIndex];
+          var subtree = selectedRoot.GetSubTree(subtreeIndex);
           minNewArgumentsForSubtrees[subtreeIndex] = 0;
           // => cut-off at 0..n points somewhere in the current sub-tree

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

@@ -33 +33 @@
   /// As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 108
   /// </summary>
-  [Item("SubroutineDeleter", "Manipulates a symbolic expression by deleting a preexisting function-defining branch.")]
+  [Item("SubroutineDeleter", "Manipulates a symbolic expression by deleting a preexisting function-defining branch. As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 108")]
   [StorableClass]
   public sealed class SubroutineDeleter : SymbolicExpressionTreeArchitectureManipulator {
@@ -47 +47 @@
     public override sealed void ModifyArchitecture(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      IntValue maxTreeSize, IntValue maxTreeHeight,
-      IntValue maxFunctionDefiningBranches, IntValue maxFunctionArguments,
-      out bool success) {
-      success = DeleteSubroutine(random, symbolicExpressionTree, grammar, maxTreeSize.Value, maxTreeHeight.Value, maxFunctionDefiningBranches.Value, maxFunctionArguments.Value);
+      ISymbolicExpressionTree symbolicExpressionTree,
+      IntValue maxFunctionDefinitions, IntValue maxFunctionArguments) {
+      DeleteSubroutine(random, symbolicExpressionTree, maxFunctionDefinitions.Value, maxFunctionArguments.Value);
     }
 
     public static bool DeleteSubroutine(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      int maxTreeSize, int maxTreeHeight,
-      int maxFunctionDefiningBranches, int maxFunctionArguments) {
+      ISymbolicExpressionTree symbolicExpressionTree,
+      int maxFunctionDefinitions, int maxFunctionArguments) {
       var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();
 
@@ -68 +63 @@
       var selectedDefunBranch = functionDefiningBranches.SelectRandom(random);
       // remove the selected defun
-      int defunSubtreeIndex = symbolicExpressionTree.Root.SubTrees.IndexOf(selectedDefunBranch);
+      int defunSubtreeIndex = symbolicExpressionTree.Root.IndexOfSubTree(selectedDefunBranch);
       symbolicExpressionTree.Root.RemoveSubTree(defunSubtreeIndex);
 
@@ -85 +80 @@
     }
 
-    private static void DeletionByRandomRegeneration(IRandom random, SymbolicExpressionTree symbolicExpressionTree, DefunTreeNode selectedDefunBranch) {
+    private static void DeletionByRandomRegeneration(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, DefunTreeNode selectedDefunBranch) {
       // find first invocation and replace it with a randomly generated tree
       // can't find all invocations in one step because once we replaced a top level invocation
@@ -92 +87 @@
                                 from subtree in node.SubTrees.OfType<InvokeFunctionTreeNode>()
                                 where subtree.Symbol.FunctionName == selectedDefunBranch.FunctionName
-                                select new { Parent = node, ReplacedChildIndex = node.SubTrees.IndexOf(subtree), ReplacedChild = subtree }).FirstOrDefault();
+                                select new { Parent = node, ReplacedChildIndex = node.IndexOfSubTree(subtree), ReplacedChild = subtree }).FirstOrDefault();
       while (invocationCutPoint != null) {
         // deletion by random regeneration
-        SymbolicExpressionTreeNode replacementTree = null;
+        ISymbolicExpressionTreeNode replacementTree = null;
         var allowedSymbolsList = invocationCutPoint.Parent.GetAllowedSymbols(invocationCutPoint.ReplacedChildIndex).ToList();
         var weights = allowedSymbolsList.Select(s => s.InitialFrequency);
@@ -115 +110 @@
                               from subtree in node.SubTrees.OfType<InvokeFunctionTreeNode>()
                               where subtree.Symbol.FunctionName == selectedDefunBranch.FunctionName
-                              select new { Parent = node, ReplacedChildIndex = node.SubTrees.IndexOf(subtree), ReplacedChild = subtree }).FirstOrDefault();
+                              select new { Parent = node, ReplacedChildIndex = node.IndexOfSubTree(subtree), ReplacedChild = subtree }).FirstOrDefault();
       }
     }

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

@@ -34 +34 @@
   /// As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 88
   /// </summary>
-  [Item("SubroutineDuplicater", "Manipulates a symbolic expression by duplicating a preexisting function-defining branch.")]
+  [Item("SubroutineDuplicater", "Manipulates a symbolic expression by duplicating a preexisting function-defining branch. As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 88")]
   [StorableClass]
   public sealed class SubroutineDuplicater : SymbolicExpressionTreeArchitectureManipulator {
@@ -50 +50 @@
     public override sealed void ModifyArchitecture(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      IntValue maxTreeSize, IntValue maxTreeHeight,
-      IntValue maxFunctionDefiningBranches, IntValue maxFunctionArguments,
-      out bool success) {
-      success = DuplicateSubroutine(random, symbolicExpressionTree, grammar, maxTreeSize.Value, maxTreeHeight.Value, maxFunctionDefiningBranches.Value, maxFunctionArguments.Value);
+      ISymbolicExpressionTree symbolicExpressionTree,
+      IntValue maxFunctionDefinitions, IntValue maxFunctionArguments) {
+      DuplicateSubroutine(random, symbolicExpressionTree, maxFunctionDefinitions.Value, maxFunctionArguments.Value);
     }
 
     public static bool DuplicateSubroutine(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      int maxTreeSize, int maxTreeHeight,
-      int maxFunctionDefiningBranches, int maxFunctionArguments) {
+      ISymbolicExpressionTree symbolicExpressionTree,
+      int maxFunctionDefinitions, int maxFunctionArguments) {
       var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();
-      if (functionDefiningBranches.Count() == 0 || functionDefiningBranches.Count() == maxFunctionDefiningBranches)
+      if (functionDefiningBranches.Count() == 0 || functionDefiningBranches.Count() == maxFunctionDefinitions)
         // no function defining branches to duplicate or already reached the max number of ADFs
         return false;
 
-      string formatString = new StringBuilder().Append('0', (int)Math.Log10(maxFunctionDefiningBranches) + 1).ToString(); // >= 100 functions => ###
-      var allowedFunctionNames = from index in Enumerable.Range(0, maxFunctionDefiningBranches)
+      string formatString = new StringBuilder().Append('0', (int)Math.Log10(maxFunctionDefinitions) + 1).ToString(); // >= 100 functions => ###
+      var allowedFunctionNames = from index in Enumerable.Range(0, maxFunctionDefinitions)
                                  select "ADF" + index.ToString(formatString);
       var selectedBranch = functionDefiningBranches.SelectRandom(random);
@@ -77 +72 @@
       duplicatedDefunBranch.FunctionName = newFunctionName;
       symbolicExpressionTree.Root.AddSubTree(duplicatedDefunBranch);
-      duplicatedDefunBranch.SetGrammar((ISymbolicExpressionGrammar)selectedBranch.Grammar.Clone());
+      duplicatedDefunBranch.SetGrammar((ISymbolicExpressionTreeGrammar)selectedBranch.Grammar.Clone());
       // add an invoke symbol for each branch that is allowed to invoke the original function
       foreach (var subtree in symbolicExpressionTree.Root.SubTrees.OfType<SymbolicExpressionTreeTopLevelNode>()) {
@@ -104 +99 @@
     }
 
-    private static IEnumerable<string> UsedFunctionNames(SymbolicExpressionTree symbolicExpressionTree) {
+    private static IEnumerable<string> UsedFunctionNames(ISymbolicExpressionTree symbolicExpressionTree) {
       return from node in symbolicExpressionTree.IterateNodesPrefix()
              where node.Symbol is Defun

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

@@ -62 +62 @@
     }
 
-    protected override sealed void Manipulate(IRandom random, SymbolicExpressionTree symbolicExpressionTree) {
+    protected override sealed void Manipulate(IRandom random, ISymbolicExpressionTree symbolicExpressionTree) {
       ModifyArchitecture(random, symbolicExpressionTree, MaximumFunctionDefinitions, MaximumFunctionArguments);
     }
@@ -68 +68 @@
     public abstract void ModifyArchitecture(
       IRandom random,
-      SymbolicExpressionTree tree,
+      ISymbolicExpressionTree tree,
       IntValue maxFunctionDefinitions,
       IntValue maxFunctionArguments);