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

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/Crossovers

Files:

• CrossoverPoint.cs (modified) (1 diff)
• SubtreeCrossover.cs (modified) (7 diffs)
• SymbolicExpressionTreeCrossover.cs (modified) (4 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/CrossoverPoint.cs

@@ -23 +23 @@
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
   internal class CrossoverPoint {
-    public SymbolicExpressionTreeNode Parent { get; set; }
-    public SymbolicExpressionTreeNode Child { get; set; }
+    public ISymbolicExpressionTreeNode Parent { get; set; }
+    public ISymbolicExpressionTreeNode Child { get; set; }
     public int SubtreeIndex {
-      get { return Parent.SubTrees.IndexOf(Child); }
+      get { return Parent.IndexOfSubTree(Child); }
     }
-    public CrossoverPoint(SymbolicExpressionTreeNode parent, SymbolicExpressionTreeNode child) {
+    public CrossoverPoint(ISymbolicExpressionTreeNode parent, ISymbolicExpressionTreeNode child) {
       this.Parent = parent;
       this.Child = child;

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs

@@ -78 +78 @@
     }
 
-    protected override SymbolicExpressionTree Cross(IRandom random,
-      SymbolicExpressionTree parent0, SymbolicExpressionTree parent1) {
+    protected override ISymbolicExpressionTree Cross(IRandom random,
+      ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1) {
       return Cross(random, parent0, parent1, InternalCrossoverPointProbability.Value,
         MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value);
     }
 
-    public static SymbolicExpressionTree Cross(IRandom random,
-      SymbolicExpressionTree parent0, SymbolicExpressionTree parent1,
+    public static ISymbolicExpressionTree Cross(IRandom random,
+      ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1,
       double internalCrossoverPointProbability, int maxTreeSize, int maxTreeHeight) {
       // select a random crossover point in the first parent 
-      SymbolicExpressionTreeNode crossoverPoint0;
+      ISymbolicExpressionTreeNode crossoverPoint0;
       int replacedSubtreeIndex;
       SelectCrossoverPoint(random, parent0, internalCrossoverPointProbability, maxTreeSize, maxTreeHeight, out crossoverPoint0, out replacedSubtreeIndex);
 
       // calculate the max size and height that the inserted branch can have 
-      int maxInsertedBranchSize = maxTreeSize - (parent0.Size - crossoverPoint0.SubTrees[replacedSubtreeIndex].GetSize());
+      int maxInsertedBranchSize = maxTreeSize - (parent0.Size - crossoverPoint0.GetSubTree(replacedSubtreeIndex).GetSize());
       int maxInsertedBranchHeight = maxTreeHeight - GetBranchLevel(parent0.Root, crossoverPoint0);
 
-      List<SymbolicExpressionTreeNode> allowedBranches = new List<SymbolicExpressionTreeNode>();
+      List<ISymbolicExpressionTreeNode> allowedBranches = new List<ISymbolicExpressionTreeNode>();
       parent1.Root.ForEachNodePostfix((n) => {
         if (n.GetSize() <= maxInsertedBranchSize &&
@@ -117 +117 @@
     }
 
-    private static bool IsMatchingPointType(SymbolicExpressionTreeNode parent, int replacedSubtreeIndex, SymbolicExpressionTreeNode branch) {
+    private static bool IsMatchingPointType(ISymbolicExpressionTreeNode parent, int replacedSubtreeIndex, ISymbolicExpressionTreeNode branch) {
       // check syntax constraints of direct parent - child relation
       if (!parent.Grammar.ContainsSymbol(branch.Symbol) ||
@@ -128 +128 @@
           result &&
           parent.Grammar.ContainsSymbol(n.Symbol) &&
-          n.SubTrees.Count >= parent.Grammar.GetMinSubtreeCount(n.Symbol) &&
-          n.SubTrees.Count <= parent.Grammar.GetMaxSubtreeCount(n.Symbol);
+          n.SubTrees.Count() >= parent.Grammar.GetMinSubtreeCount(n.Symbol) &&
+          n.SubTrees.Count() <= parent.Grammar.GetMaxSubtreeCount(n.Symbol);
       });
       return result;
     }
 
-    private static void SelectCrossoverPoint(IRandom random, SymbolicExpressionTree parent0, double internalNodeProbability, int maxBranchSize, int maxBranchHeight, out SymbolicExpressionTreeNode crossoverPoint, out int subtreeIndex) {
+    private static void SelectCrossoverPoint(IRandom random, ISymbolicExpressionTree parent0, double internalNodeProbability, int maxBranchSize, int maxBranchHeight, out ISymbolicExpressionTreeNode crossoverPoint, out int subtreeIndex) {
       if (internalNodeProbability < 0.0 || internalNodeProbability > 1.0) throw new ArgumentException("internalNodeProbability");
       List<CrossoverPoint> internalCrossoverPoints = new List<CrossoverPoint>();
       List<CrossoverPoint> leafCrossoverPoints = new List<CrossoverPoint>();
       parent0.Root.ForEachNodePostfix((n) => {
-        if (n.SubTrees.Count > 0 && n != parent0.Root) {
+        if (n.SubTrees.Count() > 0 && n != parent0.Root) {
           foreach (var child in n.SubTrees) {
             if (child.GetSize() <= maxBranchSize &&
                 child.GetHeight() <= maxBranchHeight) {
-              if (child.SubTrees.Count > 0)
+              if (child.SubTrees.Count() > 0)
                 internalCrossoverPoints.Add(new CrossoverPoint(n, child));
               else
@@ -178 +178 @@
     }
 
-    private static SymbolicExpressionTreeNode SelectRandomBranch(IRandom random, IEnumerable<SymbolicExpressionTreeNode> branches, double internalNodeProbability) {
+    private static ISymbolicExpressionTreeNode SelectRandomBranch(IRandom random, IEnumerable<ISymbolicExpressionTreeNode> branches, double internalNodeProbability) {
       if (internalNodeProbability < 0.0 || internalNodeProbability > 1.0) throw new ArgumentException("internalNodeProbability");
-      List<SymbolicExpressionTreeNode> allowedInternalBranches;
-      List<SymbolicExpressionTreeNode> allowedLeafBranches;
+      List<ISymbolicExpressionTreeNode> allowedInternalBranches;
+      List<ISymbolicExpressionTreeNode> allowedLeafBranches;
       if (random.NextDouble() < internalNodeProbability) {
         // select internal node if possible
         allowedInternalBranches = (from branch in branches
-                                   where branch.SubTrees.Count > 0
+                                   where branch.SubTrees.Count() > 0
                                    select branch).ToList();
         if (allowedInternalBranches.Count > 0) {
@@ -192 +192 @@
           // no internal nodes allowed => select leaf nodes
           allowedLeafBranches = (from branch in branches
-                                 where branch.SubTrees.Count == 0
+                                 where branch.SubTrees.Count() == 0
                                  select branch).ToList();
           return allowedLeafBranches.SelectRandom(random);
@@ -199 +199 @@
         // select leaf node if possible
         allowedLeafBranches = (from branch in branches
-                               where branch.SubTrees.Count == 0
+                               where branch.SubTrees.Count() == 0
                                select branch).ToList();
         if (allowedLeafBranches.Count > 0) {
@@ -205 +205 @@
         } else {
           allowedInternalBranches = (from branch in branches
-                                     where branch.SubTrees.Count > 0
+                                     where branch.SubTrees.Count() > 0
                                      select branch).ToList();
           return allowedInternalBranches.SelectRandom(random);

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs

@@ -37 +37 @@
     private const string ChildParameterName = "Child";
     #region Parameter Properties
-    public ILookupParameter<ItemArray<SymbolicExpressionTree>> ParentsParameter {
-      get { return (ScopeTreeLookupParameter<SymbolicExpressionTree>)Parameters[ParentsParameterName]; }
+    public ILookupParameter<ItemArray<ISymbolicExpressionTree>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[ParentsParameterName]; }
     }
-    public ILookupParameter<SymbolicExpressionTree> ChildParameter {
-      get { return (ILookupParameter<SymbolicExpressionTree>)Parameters[ChildParameterName]; }
+    public ILookupParameter<ISymbolicExpressionTree> ChildParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[ChildParameterName]; }
     }
     #endregion
     #region Properties
-    public ItemArray<SymbolicExpressionTree> Parents {
+    public ItemArray<ISymbolicExpressionTree> Parents {
       get { return ParentsParameter.ActualValue; }
     }
-    public SymbolicExpressionTree Child {
+    public ISymbolicExpressionTree Child {
       get { return ChildParameter.ActualValue; }
       set { ChildParameter.ActualValue = value; }
@@ -58 +58 @@
     protected SymbolicExpressionTreeCrossover()
       : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(ParentsParameterName, "The parent symbolic expression trees which should be crossed."));
-      Parameters.Add(new LookupParameter<SymbolicExpressionTree>(ChildParameterName, "The child symbolic expression tree resulting from the crossover."));
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(ParentsParameterName, "The parent symbolic expression trees which should be crossed."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(ChildParameterName, "The child symbolic expression tree resulting from the crossover."));
     }
 
@@ -66 +66 @@
         throw new ArgumentException("Number of parents must be exactly two for symbolic expression tree crossover operators.");
 
-      SymbolicExpressionTree result = Cross(Random, Parents[0], Parents[1]);
+      ISymbolicExpressionTree result = Cross(Random, Parents[0], Parents[1]);
 
       Child = result;
@@ -72 +72 @@
     }
 
-    protected abstract SymbolicExpressionTree Cross(IRandom random,
-      SymbolicExpressionTree parent0, SymbolicExpressionTree parent1);
+    protected abstract ISymbolicExpressionTree Cross(IRandom random,
+      ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1);
   }
 }