Changeset 6814

Timestamp:

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

Author:

mkommend

Message:

#1479: Adapted symbolic expression encoding unit tests.

Location:

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4

Files:

• SymbolicExpressionGrammarBase.cs (modified) (10 diffs)
• SymbolicExpressionTreeGrammar.cs (modified) (1 diff)
• Tests/Grammars.cs (modified) (3 diffs)
• Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.Tests.csproj (modified) (1 diff)
• Tests/ProbabilisticTreeCreaterTest.cs (modified) (1 diff)
• Tests/Util.cs (modified) (1 diff)

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;

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

@@ -82 +82 @@
     public override IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent) {
       var symbols = grammar.GetAllowedChildSymbols(parent).Union(base.GetAllowedChildSymbols(parent));
-      return symbols.SelectMany(s => s.Flatten()).Where(s => s.Enabled && !(s is GroupSymbol));
+      return symbols.SelectMany(s => s.Flatten()).Where(s => s.Enabled).Distinct();
     }
     public override IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent, int argumentIndex) {
       var symbols = grammar.GetAllowedChildSymbols(parent, argumentIndex).Union(base.GetAllowedChildSymbols(parent, argumentIndex));
-      return symbols.SelectMany(s => s.Flatten()).Where(s => s.Enabled && !(s is GroupSymbol));
+      return symbols.SelectMany(s => s.Flatten()).Where(s => s.Enabled).Distinct();
     }
 

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Grammars.cs

@@ -21 +21 @@
 
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding_3._4.Tests {
@@ -212 +214 @@
 
     public static ISymbolicExpressionGrammar CreateSimpleArithmeticGrammar() {
-      var g = new SimpleArithmeticGrammar();
+      var g = new TypeCoherentExpressionGrammar();
+      g.ConfigureAsDefaultRegressionGrammar();
+      g.Symbols.OfType<Variable>().First().Enabled = false;
+      //var g = new SimpleArithmeticGrammar();
       g.MaximumFunctionArguments = 0;
       g.MinimumFunctionArguments = 0;
@@ -221 +226 @@
 
     public static ISymbolicExpressionGrammar CreateArithmeticAndAdfGrammar() {
-      var g = new SimpleArithmeticGrammar();
+      var g = new TypeCoherentExpressionGrammar();
+      g.ConfigureAsDefaultRegressionGrammar();
+      g.Symbols.OfType<Variable>().First().Enabled = false;
       g.MaximumFunctionArguments = 3;
       g.MinimumFunctionArguments = 0;

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.Tests.csproj

@@ -149 +149 @@
       <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.Problems.DataAnalysis.Symbolic\3.4\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj">
+      <Project>{3D28463F-EC96-4D82-AFEE-38BE91A0CA00}</Project>
+      <Name>HeuristicLab.Problems.DataAnalysis.Symbolic-3.4</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
       <Project>{F4539FB6-4708-40C9-BE64-0A1390AEA197}</Project>

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ProbabilisticTreeCreaterTest.cs

@@ -72 +72 @@
         Util.GetTerminalDistributionString(randomTrees) + Environment.NewLine
         );
-      Assert.IsTrue(Math.Round(1000.0 / (msPerRandomTreeCreation)) > 500); // must achieve more than 500 random trees / s
+      Assert.IsTrue(Math.Round(1000.0 / (msPerRandomTreeCreation)) > 300); // must achieve more than 500 random trees / s
     }
   }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Util.cs

@@ -153 +153 @@
     public static void IsValid(ISymbolicExpressionTreeGrammar grammar) {
       Assert.IsTrue(grammar.Symbols.Count() == grammar.Symbols.Distinct().Count());
-      foreach (ISymbol symbol in grammar.Symbols) {
+      foreach (ISymbol symbol in grammar.AllowedSymbols) {
         Assert.IsTrue(grammar.GetMinimumSubtreeCount(symbol) <= grammar.GetMaximumExpressionLength(symbol));
         Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol).Count() == grammar.GetAllowedChildSymbols(symbol).Distinct().Count());