Changeset 14399 for branches/symbreg-factors-2650/HeuristicLab.Tests

Timestamp:

11/17/16 15:30:11 (8 years ago)

Author:

gkronber

Message:

#2650: merged r14352:14376 from trunk to branch (resolving conflicts in SymbolicDataAnalysisExpressionLatexFormatter

Location:

branches/symbreg-factors-2650

Files:

• . (modified) (1 prop)
• HeuristicLab.Tests (modified) (1 prop)
• HeuristicLab.Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4/GrammarsTest.cs (modified) (2 diffs)

branches/symbreg-factors-2650/HeuristicLab.Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4/GrammarsTest.cs

@@ -30 +30 @@
     [TestProperty("Time", "short")]
     public void MinimumExpressionLengthTest() {
-      var grammar = CreateAbstractGrammar();
-
-      var prs = grammar.ProgramRootSymbol;
-      var a = grammar.Symbols.First(s => s.Name == "<a>");
-      var b = grammar.Symbols.First(s => s.Name == "<b>");
-
-      Assert.AreEqual(4, grammar.GetMinimumExpressionLength(prs));
-      Assert.AreEqual(4, grammar.GetMinimumExpressionLength(a));
-      Assert.AreEqual(3, grammar.GetMinimumExpressionLength(b));
+      {
+        var grammar = CreateTestGrammar1();
+
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+
+        Assert.AreEqual(8, grammar.GetMinimumExpressionLength(prs));
+        Assert.AreEqual(7, grammar.GetMinimumExpressionLength(ss));
+        Assert.AreEqual(6, grammar.GetMinimumExpressionLength(x));
+      }
+
+      {
+        var grammar = CreateTestGrammar2();
+
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+
+        Assert.AreEqual(13, grammar.GetMinimumExpressionLength(prs));
+        Assert.AreEqual(12, grammar.GetMinimumExpressionLength(ss));
+        Assert.AreEqual(11, grammar.GetMinimumExpressionLength(x));
+      }
+
+      {
+        var grammar = CreateTestGrammar3();
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(prs));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(ss));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(x));
+      }
+
+      {
+        var grammar = CreateTestGrammar4();
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+        var y = grammar.Symbols.First(s => s.Name == "<y>");
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(prs));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(ss));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(x));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(y));
+      }
+
+      {
+        var grammar = CreateTestGrammar5();
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+        var y = grammar.Symbols.First(s => s.Name == "<y>");
+        Assert.AreEqual(5, grammar.GetMinimumExpressionLength(prs));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(ss));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(x));
+        Assert.AreEqual(2, grammar.GetMinimumExpressionLength(y));
+      }
+
+      {
+        var grammar = CreateTestGrammar6();
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+        var s_ = grammar.Symbols.First(s => s.Name == "<s>");
+        var a = grammar.Symbols.First(s => s.Name == "<a>");
+        var b = grammar.Symbols.First(s => s.Name == "<b>");
+        var c = grammar.Symbols.First(s => s.Name == "<c>");
+        var d = grammar.Symbols.First(s => s.Name == "<d>");
+        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(prs));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(ss));
+        Assert.AreEqual(2, grammar.GetMinimumExpressionLength(x));
+        Assert.AreEqual(5, grammar.GetMinimumExpressionLength(s_));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(a));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(b));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(c));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(d));
+      }
     }
 
@@ -45 +113 @@
     [TestProperty("Time", "short")]
     public void MinimumExpressionDepthTest() {
-      var grammar = CreateAbstractGrammar();
-
-      var prs = grammar.ProgramRootSymbol;
-      var a = grammar.Symbols.First(s => s.Name == "<a>");
-      var b = grammar.Symbols.First(s => s.Name == "<b>");
-
-      Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(prs));
-      Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(a));
-      Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(b));
-    }
-
-    private static ISymbolicExpressionGrammar CreateAbstractGrammar() {
+      {
+        var grammar = CreateTestGrammar1();
+
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var a = grammar.Symbols.First(s => s.Name == "<a>");
+        var b = grammar.Symbols.First(s => s.Name == "<b>");
+        var c = grammar.Symbols.First(s => s.Name == "<c>");
+        var d = grammar.Symbols.First(s => s.Name == "<d>");
+        var x = grammar.Symbols.First(s => s.Name == "x");
+        var y = grammar.Symbols.First(s => s.Name == "y");
+
+        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(prs));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(ss));
+        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(a));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(b));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(c));
+        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(d));
+        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(x));
+        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(y));
+      }
+
+      {
+        var grammar = CreateTestGrammar2();
+
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var a = grammar.Symbols.First(s => s.Name == "<a>");
+        var b = grammar.Symbols.First(s => s.Name == "<b>");
+        var c = grammar.Symbols.First(s => s.Name == "<c>");
+        var d = grammar.Symbols.First(s => s.Name == "<d>");
+        var x = grammar.Symbols.First(s => s.Name == "x");
+        var y = grammar.Symbols.First(s => s.Name == "y");
+
+        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(prs));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(ss));
+        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(a));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(b));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(c));
+        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(d));
+        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(x));
+        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(y));
+      }
+
+      {
+        var grammar = CreateTestGrammar3();
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(prs));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(ss));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(x));
+      }
+
+      {
+        var grammar = CreateTestGrammar4();
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+        var y = grammar.Symbols.First(s => s.Name == "<y>");
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(prs));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(ss));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(x));
+        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(y));
+      }
+
+      {
+        var grammar = CreateTestGrammar5();
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+        var y = grammar.Symbols.First(s => s.Name == "<y>");
+        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(prs));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(ss));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(x));
+        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(y));
+      }
+
+      {
+        var grammar = CreateTestGrammar6();
+        var prs = grammar.ProgramRootSymbol;
+        var ss = grammar.StartSymbol;
+        var x = grammar.Symbols.First(s => s.Name == "<x>");
+        var s_ = grammar.Symbols.First(s => s.Name == "<s>");
+        var a = grammar.Symbols.First(s => s.Name == "<a>");
+        var b = grammar.Symbols.First(s => s.Name == "<b>");
+        var c = grammar.Symbols.First(s => s.Name == "<c>");
+        var d = grammar.Symbols.First(s => s.Name == "<d>");
+        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(prs));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(ss));
+        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(x));
+        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(s_));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(a));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(b));
+        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(c));
+        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(d));
+      }
+    }
+
+    private static ISymbolicExpressionGrammar CreateTestGrammar1() {
+      var grammar = new SimpleSymbolicExpressionGrammar();
+      var x = new SimpleSymbol("<x>", 1);
+      var z = new SimpleSymbol("<z>", 6);
+      var a = new SimpleSymbol("<a>", 1);
+      var b = new SimpleSymbol("<b>", 1);
+      var c = new SimpleSymbol("<c>", 1);
+      var d = new SimpleSymbol("<d>", 1);
+
+      var _x = new SimpleSymbol("x", 0);
+      var _y = new SimpleSymbol("y", 0);
+
+      grammar.AddSymbol(x);
+      grammar.AddSymbol(z);
+      grammar.AddSymbol(a);
+      grammar.AddSymbol(b);
+      grammar.AddSymbol(c);
+      grammar.AddSymbol(d);
+      grammar.AddSymbol(_x);
+      grammar.AddSymbol(_y);
+
+      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
+      //uncommenting the line below changes the minimum expression length for the symbol <x>
+      grammar.AddAllowedChildSymbol(x, z);
+      grammar.AddAllowedChildSymbol(z, _x);
+      grammar.AddAllowedChildSymbol(x, a);
+      grammar.AddAllowedChildSymbol(a, b);
+      grammar.AddAllowedChildSymbol(b, c);
+      grammar.AddAllowedChildSymbol(c, d);
+      grammar.AddAllowedChildSymbol(d, _y);
+
+      return grammar;
+    }
+
+    private static ISymbolicExpressionGrammar CreateTestGrammar2() {
+      var grammar = new SimpleSymbolicExpressionGrammar();
+      var x = new SimpleSymbol("<x>", 2);
+      var z = new SimpleSymbol("<z>", 6);
+      var a = new SimpleSymbol("<a>", 1);
+      var b = new SimpleSymbol("<b>", 1);
+      var c = new SimpleSymbol("<c>", 1);
+      var d = new SimpleSymbol("<d>", 1);
+
+      var _x = new SimpleSymbol("x", 0);
+      var _y = new SimpleSymbol("y", 0);
+
+      grammar.AddSymbol(x);
+      grammar.AddSymbol(z);
+      grammar.AddSymbol(a);
+      grammar.AddSymbol(b);
+      grammar.AddSymbol(c);
+      grammar.AddSymbol(d);
+      grammar.AddSymbol(_x);
+      grammar.AddSymbol(_y);
+
+      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
+      //uncommenting the line below changes the minimum expression length for the symbol <x>
+      grammar.AddAllowedChildSymbol(x, z);
+      grammar.AddAllowedChildSymbol(z, _x);
+      grammar.AddAllowedChildSymbol(x, a);
+      grammar.AddAllowedChildSymbol(a, b);
+      grammar.AddAllowedChildSymbol(b, c);
+      grammar.AddAllowedChildSymbol(c, d);
+      grammar.AddAllowedChildSymbol(d, _y);
+
+      return grammar;
+    }
+
+    private static ISymbolicExpressionGrammar CreateTestGrammar3() {
+      var grammar = new SimpleSymbolicExpressionGrammar();
+      var x = new SimpleSymbol("<x>", 1);
+
+      grammar.AddSymbol(x);
+
+      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
+      grammar.AddAllowedChildSymbol(x, x);
+      return grammar;
+    }
+
+
+    private static ISymbolicExpressionGrammar CreateTestGrammar4() {
+      var grammar = new SimpleSymbolicExpressionGrammar();
+      var x = new SimpleSymbol("<x>", 1);
+      var y = new SimpleSymbol("<y>", 1);
+
+      grammar.AddSymbol(x);
+      grammar.AddSymbol(y);
+
+      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
+      grammar.AddAllowedChildSymbol(x, x);
+      grammar.AddAllowedChildSymbol(x, y);
+      grammar.AddAllowedChildSymbol(y, x);
+      grammar.AddAllowedChildSymbol(y, y);
+      return grammar;
+    }
+
+    private static ISymbolicExpressionGrammar CreateTestGrammar5() {
+      var grammar = new SimpleSymbolicExpressionGrammar();
+      var x = new SimpleSymbol("<x>", 1);
+      var y = new SimpleSymbol("<y>", 1);
+      var _x = new SimpleSymbol("x", 0);
+
+      grammar.AddSymbol(x);
+      grammar.AddSymbol(y);
+      grammar.AddSymbol(_x);
+
+      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
+      grammar.AddAllowedChildSymbol(x, x);
+      grammar.AddAllowedChildSymbol(x, y);
+      grammar.AddAllowedChildSymbol(y, x);
+      grammar.AddAllowedChildSymbol(y, y);
+      grammar.AddAllowedChildSymbol(y, _x);
+      return grammar;
+    }
+
+    private static ISymbolicExpressionGrammar CreateTestGrammar6() {
       var grammar = new SimpleSymbolicExpressionGrammar();
       var x = new SimpleSymbol("<x>", 1);