Changeset 6814 for trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs

Timestamp:

09/21/11 15:51:43 (13 years ago)

Author:

mkommend

Message:

#1479: Adapted symbolic expression encoding unit tests.

File:

• trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs (modified) (10 diffs)

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs

@@ -52 +52 @@
     [Storable(Name = "AllowedChildSymbols")]
     private IEnumerable<KeyValuePair<ISymbol, IEnumerable<ISymbol>>> StorableAllowedChildSymbols {
-      get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(y => GetSymbol(y)).ToArray())).ToArray(); }
+      get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(GetSymbol).ToArray())).ToArray(); }
       set { allowedChildSymbols = value.ToDictionary(x => x.Key.Name, x => x.Value.Select(y => y.Name).ToList()); }
     }
@@ -83 +83 @@
       cachedMinExpressionDepth = new Dictionary<string, int>();
 
+      cachedIsAllowedChildSymbol = new Dictionary<Tuple<string, string>, bool>();
+      cachedIsAllowedChildSymbolIndex = new Dictionary<Tuple<string, string, int>, bool>();
+
       suppressEvents = false;
     }
@@ -92 +95 @@
       cachedMinExpressionDepth = new Dictionary<string, int>();
 
-      symbols = original.symbols.ToDictionary(x => x.Key, y => (ISymbol)cloner.Clone(y.Value));
+      cachedIsAllowedChildSymbol = new Dictionary<Tuple<string, string>, bool>();
+      cachedIsAllowedChildSymbolIndex = new Dictionary<Tuple<string, string, int>, bool>();
+
+      symbols = original.symbols.ToDictionary(x => x.Key, y => cloner.Clone(y.Value));
       symbolSubtreeCount = new Dictionary<string, Tuple<int, int>>(original.symbolSubtreeCount);
 
@@ -111 +117 @@
       cachedMaxExpressionLength = new Dictionary<string, int>();
       cachedMinExpressionDepth = new Dictionary<string, int>();
+
+      cachedIsAllowedChildSymbol = new Dictionary<Tuple<string, string>, bool>();
+      cachedIsAllowedChildSymbolIndex = new Dictionary<Tuple<string, string, int>, bool>();
 
       symbols = new Dictionary<string, ISymbol>();
@@ -301 +310 @@
     }
 
+    private readonly Dictionary<Tuple<string, string>, bool> cachedIsAllowedChildSymbol;
     public virtual bool IsAllowedChildSymbol(ISymbol parent, ISymbol child) {
       if (!child.Enabled) return false;
 
+      bool result;
+      if (cachedIsAllowedChildSymbol.TryGetValue(Tuple.Create(parent.Name, child.Name), out result)) return result;
       List<string> temp;
       if (allowedChildSymbols.TryGetValue(parent.Name, out temp)) {
-        if (temp.Contains(child.Name)) return true;
-        if (temp.SelectMany(s => GetSymbol(s).Flatten().Select(n => n.Name)).Contains(child.Name)) return true;
-      }
+        //if (temp.Contains(child.Name)) return true;
+        if (temp.SelectMany(s => GetSymbol(s).Flatten()).Where(s => s.Name == child.Name).Any()) {
+          cachedIsAllowedChildSymbol.Add(Tuple.Create(parent.Name, child.Name), true);
+          return true;
+        }
+      }
+      cachedIsAllowedChildSymbol.Add(Tuple.Create(parent.Name, child.Name), false);
       return false;
     }
 
+    private readonly Dictionary<Tuple<string, string, int>, bool> cachedIsAllowedChildSymbolIndex;
     public virtual bool IsAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
       if (!child.Enabled) return false;
       if (IsAllowedChildSymbol(parent, child)) return true;
 
+      bool result;
+      if (cachedIsAllowedChildSymbolIndex.TryGetValue(Tuple.Create(parent.Name, child.Name, argumentIndex), out result)) return result;
       List<string> temp;
       var key = Tuple.Create(parent.Name, argumentIndex);
       if (allowedChildSymbolsPerIndex.TryGetValue(key, out temp)) {
-        if (temp.Contains(child.Name)) return true;
-        if (temp.SelectMany(s => GetSymbol(s).Flatten().Select(n => n.Name)).Contains(child.Name)) return true;
-      }
+        //if (temp.Contains(child.Name)) return true;
+        if (temp.SelectMany(s => GetSymbol(s).Flatten()).Where(s => s.Name == child.Name).Any()) {
+          cachedIsAllowedChildSymbolIndex.Add(Tuple.Create(parent.Name, child.Name, argumentIndex), true);
+          return true;
+        }
+      }
+      cachedIsAllowedChildSymbolIndex.Add(Tuple.Create(parent.Name, child.Name, argumentIndex), false);
       return false;
     }
@@ -330 +353 @@
         return Enumerable.Empty<ISymbol>();
 
-      return childs.Select(x => GetSymbol(x)).Where(s => s.Enabled);
+      return childs.Select(GetSymbol).Where(s => s.Enabled);
     }
 
@@ -343 +366 @@
         result = result.Union(temp);
 
-      return result.Select(x => GetSymbol(x)).Where(s => s.Enabled);
+      return result.Select(GetSymbol).Where(s => s.Enabled);
     }
 
@@ -357 +380 @@
       cachedMaxExpressionLength.Clear();
       cachedMinExpressionDepth.Clear();
-    }
-
-    private Dictionary<string, int> cachedMinExpressionLength;
+
+      cachedIsAllowedChildSymbol.Clear();
+      cachedIsAllowedChildSymbolIndex.Clear();
+    }
+
+    private readonly Dictionary<string, int> cachedMinExpressionLength;
     public int GetMinimumExpressionLength(ISymbol symbol) {
       int temp;
@@ -375 +401 @@
     }
 
-    private Dictionary<string, int> cachedMaxExpressionLength;
+    private readonly Dictionary<string, int> cachedMaxExpressionLength;
     public int GetMaximumExpressionLength(ISymbol symbol) {
       int temp;
@@ -390 +416 @@
     }
 
-    private Dictionary<string, int> cachedMinExpressionDepth;
+    private readonly Dictionary<string, int> cachedMinExpressionDepth;
     public int GetMinimumExpressionDepth(ISymbol symbol) {
       int temp;