Changeset 4249 for trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding

Timestamp:

08/18/10 14:57:11 (14 years ago)

Author:

mkommend

Message:

Refactored grammars (ticket #1028).

Location:

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3

Files:

• ArchitectureManipulators/SubroutineCreater.cs (modified) (1 diff)
• ArchitectureManipulators/SubroutineDuplicater.cs (modified) (1 diff)
• Creators/ProbabilisticTreeCreator.cs (modified) (2 diffs)
• DefaultSymbolicExpressionGrammar.cs (modified) (4 diffs)
• GlobalSymbolicExpressionGrammar.cs (modified) (4 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.3.csproj (modified) (1 diff)
• SymbolicExpressionTreeGrammar.cs (added)
• SymbolicExpressionTreeNode.cs (modified) (1 diff)
• SymbolicExpressionTreeTopLevelNode.cs (modified) (3 diffs)

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/ArchitectureManipulators/SubroutineCreater.cs

@@ -111 +111 @@
       symbolicExpressionTree.Root.AddSubTree(defunNode);
       // the grammar in the newly defined function is a clone of the grammar of the originating branch
-      defunNode.Grammar = (ISymbolicExpressionGrammar)selectedBody.Grammar.Clone();
+      defunNode.SetGrammar((ISymbolicExpressionGrammar)selectedBody.Grammar.Clone());
       // remove all argument symbols from grammar
       var oldArgumentSymbols = defunNode.Grammar.Symbols.OfType<Argument>().ToList();

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/ArchitectureManipulators/SubroutineDuplicater.cs

@@ -66 +66 @@
       duplicatedDefunBranch.FunctionName = newFunctionName;
       symbolicExpressionTree.Root.AddSubTree(duplicatedDefunBranch);
-      duplicatedDefunBranch.Grammar = (ISymbolicExpressionGrammar)selectedBranch.Grammar.Clone();
+      duplicatedDefunBranch.SetGrammar((ISymbolicExpressionGrammar)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>()) {

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Creators/ProbabilisticTreeCreator.cs

@@ -53 +53 @@
       ) {
       SymbolicExpressionTree tree = new SymbolicExpressionTree();
-      var rootNode = grammar.StartSymbol.CreateTreeNode();
+      var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode();
       if (rootNode.HasLocalParameters) rootNode.ResetLocalParameters(random);
-      rootNode.Grammar = grammar;
+      rootNode.SetGrammar(new SymbolicExpressionTreeGrammar(grammar));
       tree.Root = PTC2(random, rootNode, maxTreeSize, maxTreeHeight, maxFunctionDefinitions, maxFunctionArguments);
       return tree;
@@ -186 +186 @@
       // also assumes that newTree is already attached to root somewhere
       if (IsTopLevelBranch(root, newTree)) {
-        newTree.Grammar = (ISymbolicExpressionGrammar)root.Grammar.Clone();
+        ((SymbolicExpressionTreeTopLevelNode)newTree).SetGrammar((ISymbolicExpressionGrammar)root.Grammar.Clone());
 
         // allow invokes of existing ADFs with higher index

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/DefaultSymbolicExpressionGrammar.cs

@@ -90 +90 @@
     public DefaultSymbolicExpressionGrammar()
       : base() {
-      minSubTreeCount = new Dictionary<string, int>();
-      maxSubTreeCount = new Dictionary<string, int>();
-      allowedChildSymbols = new Dictionary<string, List<List<string>>>();
-      allSymbols = new Dictionary<string, Symbol>();
-
-      cachedMinExpressionLength = new Dictionary<string, int>();
-      cachedMaxExpressionLength = new Dictionary<string, int>();
-      cachedMinExpressionDepth = new Dictionary<string, int>();
-
-      startSymbol = new StartSymbol();
-      AddSymbol(startSymbol);
-      SetMinSubtreeCount(startSymbol, 1);
-      SetMaxSubtreeCount(startSymbol, 1);
-    }
-
-    //copy constructor for cloning
-    protected DefaultSymbolicExpressionGrammar(DefaultSymbolicExpressionGrammar copy)
+      this.minSubTreeCount = new Dictionary<string, int>();
+      this.maxSubTreeCount = new Dictionary<string, int>();
+      this.allowedChildSymbols = new Dictionary<string, List<List<string>>>();
+      this.allSymbols = new Dictionary<string, Symbol>();
+      this.cachedMinExpressionLength = new Dictionary<string, int>();
+      this.cachedMaxExpressionLength = new Dictionary<string, int>();
+      this.cachedMinExpressionDepth = new Dictionary<string, int>();
+
+      this.startSymbol = new StartSymbol();
+      this.AddSymbol(startSymbol);
+      this.SetMinSubtreeCount(startSymbol, 1);
+      this.SetMaxSubtreeCount(startSymbol, 1);
+    }
+
+    protected DefaultSymbolicExpressionGrammar(ISymbolicExpressionGrammar grammar)
       : base() {
-      this.minSubTreeCount = new Dictionary<string, int>(copy.minSubTreeCount);
-      this.maxSubTreeCount = new Dictionary<string, int>(copy.maxSubTreeCount);
-
-      this.startSymbol = copy.startSymbol;
+      Cloner cloner = new Cloner();
+      this.cachedMinExpressionLength = new Dictionary<string, int>();
+      this.cachedMaxExpressionLength = new Dictionary<string, int>();
+      this.cachedMinExpressionDepth = new Dictionary<string, int>();
+
+      this.minSubTreeCount = new Dictionary<string, int>();
+      this.maxSubTreeCount = new Dictionary<string, int>();
       this.allowedChildSymbols = new Dictionary<string, List<List<string>>>();
-      foreach (var entry in copy.allowedChildSymbols) {
-        this.allowedChildSymbols[entry.Key] = new List<List<string>>(entry.Value.Count);
-        foreach (var set in entry.Value) {
-          this.allowedChildSymbols[entry.Key].Add(new List<string>(set));
+      this.allSymbols = new Dictionary<string, Symbol>();
+
+      this.StartSymbol = (Symbol)cloner.Clone(grammar.StartSymbol);
+
+      foreach (Symbol symbol in grammar.Symbols) {
+        Symbol clonedSymbol = (Symbol)cloner.Clone(symbol);
+        this.AddSymbol(clonedSymbol);
+        this.SetMinSubtreeCount(clonedSymbol, grammar.GetMinSubtreeCount(symbol));
+        this.SetMaxSubtreeCount(clonedSymbol, grammar.GetMaxSubtreeCount(symbol));
+      }
+
+      foreach (Symbol parent in grammar.Symbols) {
+        for (int i = 0; i < grammar.GetMaxSubtreeCount(parent); i++) {
+          foreach (Symbol child in grammar.Symbols) {
+            if (grammar.IsAllowedChild(parent, child, i)) {
+              this.SetAllowedChild((Symbol)cloner.Clone(parent), (Symbol)cloner.Clone(child), i);
+            }
+          }
         }
       }
-      this.allSymbols = new Dictionary<string, Symbol>(copy.allSymbols);
-
-      cachedMinExpressionLength = new Dictionary<string, int>();
-      cachedMaxExpressionLength = new Dictionary<string, int>();
-      cachedMinExpressionDepth = new Dictionary<string, int>();
     }
 
@@ -151 +161 @@
 
     #region ISymbolicExpressionGrammar Members
-
     public Symbol StartSymbol {
       get { return startSymbol; }
@@ -272 +281 @@
       return maxSubTreeCount[symbol.Name];
     }
-
     #endregion
 
@@ -282 +290 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      DefaultSymbolicExpressionGrammar clone = new DefaultSymbolicExpressionGrammar(this);
-      cloner.RegisterClonedObject(this, clone);
+      DefaultSymbolicExpressionGrammar clone = (DefaultSymbolicExpressionGrammar)base.Clone(cloner);
+
+      clone.minSubTreeCount = new Dictionary<string, int>(this.minSubTreeCount);
+      clone.maxSubTreeCount = new Dictionary<string, int>(this.maxSubTreeCount);
+
+      clone.allSymbols = new Dictionary<string, Symbol>();
+      foreach (Symbol symbol in this.allSymbols.Values.Select(s => cloner.Clone(s)))
+        clone.allSymbols.Add(symbol.Name, symbol);
+
+      clone.startSymbol = (Symbol)cloner.Clone(this.startSymbol);
+      clone.allowedChildSymbols = new Dictionary<string, List<List<string>>>();
+      foreach (var entry in this.allowedChildSymbols) {
+        clone.allowedChildSymbols[entry.Key] = new List<List<string>>(entry.Value.Count);
+        foreach (var set in entry.Value) {
+          clone.allowedChildSymbols[entry.Key].Add(new List<string>(set));
+        }
+      }
+
       return clone;
     }
+
+    protected void InitializeShallowClone(DefaultSymbolicExpressionGrammar clone) {
+      clone.minSubTreeCount = new Dictionary<string, int>(this.minSubTreeCount);
+      clone.maxSubTreeCount = new Dictionary<string, int>(this.maxSubTreeCount);
+
+      clone.allSymbols = new Dictionary<string, Symbol>(this.allSymbols);
+      clone.startSymbol = this.startSymbol;
+      clone.allowedChildSymbols = new Dictionary<string, List<List<string>>>(this.allowedChildSymbols.Count);
+      foreach (var entry in this.allowedChildSymbols) {
+        clone.allowedChildSymbols[entry.Key] = new List<List<string>>(entry.Value.Count);
+        foreach (var set in entry.Value) {
+          clone.allowedChildSymbols[entry.Key].Add(new List<string>(set));
+        }
+      }
+    }
+
   }
 }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/GlobalSymbolicExpressionGrammar.cs

@@ -20 +20 @@
 #endregion
 
+using System;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -67 +69 @@
     private Defun defunSymbol;
 
-
-
     public GlobalSymbolicExpressionGrammar(ISymbolicExpressionGrammar mainBranchGrammar)
-      : base() {
+      : base(mainBranchGrammar) {
       maxFunctionArguments = 3;
       maxFunctionDefinitions = 3;
-      Initialize(mainBranchGrammar);
+
+      ProgramRootSymbol programRootSymbol = Symbols.OfType<ProgramRootSymbol>().FirstOrDefault();
+      if (programRootSymbol == null) {
+        programRootSymbol = new ProgramRootSymbol();
+        AddSymbol(programRootSymbol);
+      }
+      StartSymbol = programRootSymbol;
+
+      defunSymbol = Symbols.OfType<Defun>().FirstOrDefault();
+      if (defunSymbol == null) {
+        defunSymbol = new Defun();
+        AddSymbol(defunSymbol);
+      }
+
+      SetMinSubtreeCount(StartSymbol, minFunctionDefinitions + 1);
+      SetMaxSubtreeCount(StartSymbol, maxFunctionDefinitions + 1);
+      SetMinSubtreeCount(defunSymbol, 1);
+      SetMaxSubtreeCount(defunSymbol, 1);
+
+      // the start symbol of the mainBranchGrammar is allowed as the result producing branch
+      SetAllowedChild(StartSymbol, Symbols.Where(s => s.Name == mainBranchGrammar.StartSymbol.Name).First(), 0);
+
+      // every symbol of the mainBranchGrammar that is allowed as child of the start symbol is also allowed as direct child of defun
+      foreach (var symb in mainBranchGrammar.Symbols) {
+        if (mainBranchGrammar.IsAllowedChild(mainBranchGrammar.StartSymbol, symb, 0))
+          SetAllowedChild(defunSymbol, Symbols.Where(s => s.Name == symb.Name).First(), 0);
+      }
     }
 
-    //copy constructor for cloning
-    protected GlobalSymbolicExpressionGrammar(GlobalSymbolicExpressionGrammar copy)
-      : base(copy) {
-      this.maxFunctionArguments = copy.maxFunctionArguments;
-      this.minFunctionArguments = copy.minFunctionArguments;
-      this.maxFunctionDefinitions = copy.maxFunctionDefinitions;
-      this.minFunctionDefinitions = copy.minFunctionDefinitions;
-    }
-
+    //ctor for cloning
+    protected GlobalSymbolicExpressionGrammar() : base() { }
     [StorableConstructor]
     protected GlobalSymbolicExpressionGrammar(bool deserializing)
@@ -90 +109 @@
     }
 
+    [Obsolete]
     private void Initialize(ISymbolicExpressionGrammar mainBranchGrammar) {
       base.Clear();
@@ -151 +171 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      GlobalSymbolicExpressionGrammar clone = new GlobalSymbolicExpressionGrammar(this);
-      cloner.RegisterClonedObject(this, clone);
+      GlobalSymbolicExpressionGrammar clone = (GlobalSymbolicExpressionGrammar)base.Clone(cloner);
+      clone.defunSymbol = (Defun)cloner.Clone(this.defunSymbol);
+      clone.maxFunctionArguments = this.maxFunctionArguments;
+      clone.minFunctionArguments = this.minFunctionArguments;
+      clone.maxFunctionDefinitions = this.maxFunctionDefinitions;
+      clone.minFunctionDefinitions = this.minFunctionDefinitions;
       return clone;
     }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.3.csproj

@@ -135 +135 @@
     <Compile Include="Manipulators\OnePointShaker.cs" />
     <Compile Include="Manipulators\SymbolicExpressionTreeManipulator.cs" />
+    <Compile Include="SymbolicExpressionTreeGrammar.cs" />
     <Compile Include="SymbolicExpressionTreeStringFormatter.cs" />
     <Compile Include="SymbolicExpressionTreeTopLevelNode.cs" />

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeNode.cs

@@ -87 +87 @@
     public virtual ISymbolicExpressionGrammar Grammar {
       get { return parent.Grammar; }
-      set { throw new NotSupportedException("Grammar can be set only for SymbolicExpressionTreeTopLevelNodes."); }
     }
 

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeTopLevelNode.cs

@@ -26 +26 @@
   [StorableClass]
   public class SymbolicExpressionTreeTopLevelNode : SymbolicExpressionTreeNode {
-
     public SymbolicExpressionTreeTopLevelNode()
       : base() {
@@ -39 +38 @@
     public override ISymbolicExpressionGrammar Grammar {
       get { return grammar; }
-      set { grammar = value; }
+    }
+    public void SetGrammar(ISymbolicExpressionGrammar grammar) {
+      this.grammar = grammar;
     }
 
@@ -47 +48 @@
       if (original.Grammar != null)
         grammar = (ISymbolicExpressionGrammar)original.Grammar.Clone();
+      //grammar = original.grammar;
     }