Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
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:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/symbreg-factors-2650

  • branches/symbreg-factors-2650/HeuristicLab.Tests

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

    r14351 r14399  
    3030    [TestProperty("Time", "short")]
    3131    public void MinimumExpressionLengthTest() {
    32       var grammar = CreateAbstractGrammar();
    33 
    34       var prs = grammar.ProgramRootSymbol;
    35       var a = grammar.Symbols.First(s => s.Name == "<a>");
    36       var b = grammar.Symbols.First(s => s.Name == "<b>");
    37 
    38       Assert.AreEqual(4, grammar.GetMinimumExpressionLength(prs));
    39       Assert.AreEqual(4, grammar.GetMinimumExpressionLength(a));
    40       Assert.AreEqual(3, grammar.GetMinimumExpressionLength(b));
     32      {
     33        var grammar = CreateTestGrammar1();
     34
     35        var prs = grammar.ProgramRootSymbol;
     36        var ss = grammar.StartSymbol;
     37        var x = grammar.Symbols.First(s => s.Name == "<x>");
     38
     39        Assert.AreEqual(8, grammar.GetMinimumExpressionLength(prs));
     40        Assert.AreEqual(7, grammar.GetMinimumExpressionLength(ss));
     41        Assert.AreEqual(6, grammar.GetMinimumExpressionLength(x));
     42      }
     43
     44      {
     45        var grammar = CreateTestGrammar2();
     46
     47        var prs = grammar.ProgramRootSymbol;
     48        var ss = grammar.StartSymbol;
     49        var x = grammar.Symbols.First(s => s.Name == "<x>");
     50
     51        Assert.AreEqual(13, grammar.GetMinimumExpressionLength(prs));
     52        Assert.AreEqual(12, grammar.GetMinimumExpressionLength(ss));
     53        Assert.AreEqual(11, grammar.GetMinimumExpressionLength(x));
     54      }
     55
     56      {
     57        var grammar = CreateTestGrammar3();
     58        var prs = grammar.ProgramRootSymbol;
     59        var ss = grammar.StartSymbol;
     60        var x = grammar.Symbols.First(s => s.Name == "<x>");
     61        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(prs));
     62        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(ss));
     63        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(x));
     64      }
     65
     66      {
     67        var grammar = CreateTestGrammar4();
     68        var prs = grammar.ProgramRootSymbol;
     69        var ss = grammar.StartSymbol;
     70        var x = grammar.Symbols.First(s => s.Name == "<x>");
     71        var y = grammar.Symbols.First(s => s.Name == "<y>");
     72        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(prs));
     73        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(ss));
     74        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(x));
     75        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionLength(y));
     76      }
     77
     78      {
     79        var grammar = CreateTestGrammar5();
     80        var prs = grammar.ProgramRootSymbol;
     81        var ss = grammar.StartSymbol;
     82        var x = grammar.Symbols.First(s => s.Name == "<x>");
     83        var y = grammar.Symbols.First(s => s.Name == "<y>");
     84        Assert.AreEqual(5, grammar.GetMinimumExpressionLength(prs));
     85        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(ss));
     86        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(x));
     87        Assert.AreEqual(2, grammar.GetMinimumExpressionLength(y));
     88      }
     89
     90      {
     91        var grammar = CreateTestGrammar6();
     92        var prs = grammar.ProgramRootSymbol;
     93        var ss = grammar.StartSymbol;
     94        var x = grammar.Symbols.First(s => s.Name == "<x>");
     95        var s_ = grammar.Symbols.First(s => s.Name == "<s>");
     96        var a = grammar.Symbols.First(s => s.Name == "<a>");
     97        var b = grammar.Symbols.First(s => s.Name == "<b>");
     98        var c = grammar.Symbols.First(s => s.Name == "<c>");
     99        var d = grammar.Symbols.First(s => s.Name == "<d>");
     100        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(prs));
     101        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(ss));
     102        Assert.AreEqual(2, grammar.GetMinimumExpressionLength(x));
     103        Assert.AreEqual(5, grammar.GetMinimumExpressionLength(s_));
     104        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(a));
     105        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(b));
     106        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(c));
     107        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(d));
     108      }
    41109    }
    42110
     
    45113    [TestProperty("Time", "short")]
    46114    public void MinimumExpressionDepthTest() {
    47       var grammar = CreateAbstractGrammar();
    48 
    49       var prs = grammar.ProgramRootSymbol;
    50       var a = grammar.Symbols.First(s => s.Name == "<a>");
    51       var b = grammar.Symbols.First(s => s.Name == "<b>");
    52 
    53       Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(prs));
    54       Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(a));
    55       Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(b));
    56     }
    57 
    58     private static ISymbolicExpressionGrammar CreateAbstractGrammar() {
     115      {
     116        var grammar = CreateTestGrammar1();
     117
     118        var prs = grammar.ProgramRootSymbol;
     119        var ss = grammar.StartSymbol;
     120        var a = grammar.Symbols.First(s => s.Name == "<a>");
     121        var b = grammar.Symbols.First(s => s.Name == "<b>");
     122        var c = grammar.Symbols.First(s => s.Name == "<c>");
     123        var d = grammar.Symbols.First(s => s.Name == "<d>");
     124        var x = grammar.Symbols.First(s => s.Name == "x");
     125        var y = grammar.Symbols.First(s => s.Name == "y");
     126
     127        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(prs));
     128        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(ss));
     129        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(a));
     130        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(b));
     131        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(c));
     132        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(d));
     133        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(x));
     134        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(y));
     135      }
     136
     137      {
     138        var grammar = CreateTestGrammar2();
     139
     140        var prs = grammar.ProgramRootSymbol;
     141        var ss = grammar.StartSymbol;
     142        var a = grammar.Symbols.First(s => s.Name == "<a>");
     143        var b = grammar.Symbols.First(s => s.Name == "<b>");
     144        var c = grammar.Symbols.First(s => s.Name == "<c>");
     145        var d = grammar.Symbols.First(s => s.Name == "<d>");
     146        var x = grammar.Symbols.First(s => s.Name == "x");
     147        var y = grammar.Symbols.First(s => s.Name == "y");
     148
     149        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(prs));
     150        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(ss));
     151        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(a));
     152        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(b));
     153        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(c));
     154        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(d));
     155        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(x));
     156        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(y));
     157      }
     158
     159      {
     160        var grammar = CreateTestGrammar3();
     161        var prs = grammar.ProgramRootSymbol;
     162        var ss = grammar.StartSymbol;
     163        var x = grammar.Symbols.First(s => s.Name == "<x>");
     164        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(prs));
     165        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(ss));
     166        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(x));
     167      }
     168
     169      {
     170        var grammar = CreateTestGrammar4();
     171        var prs = grammar.ProgramRootSymbol;
     172        var ss = grammar.StartSymbol;
     173        var x = grammar.Symbols.First(s => s.Name == "<x>");
     174        var y = grammar.Symbols.First(s => s.Name == "<y>");
     175        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(prs));
     176        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(ss));
     177        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(x));
     178        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(y));
     179      }
     180
     181      {
     182        var grammar = CreateTestGrammar5();
     183        var prs = grammar.ProgramRootSymbol;
     184        var ss = grammar.StartSymbol;
     185        var x = grammar.Symbols.First(s => s.Name == "<x>");
     186        var y = grammar.Symbols.First(s => s.Name == "<y>");
     187        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(prs));
     188        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(ss));
     189        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(x));
     190        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(y));
     191      }
     192
     193      {
     194        var grammar = CreateTestGrammar6();
     195        var prs = grammar.ProgramRootSymbol;
     196        var ss = grammar.StartSymbol;
     197        var x = grammar.Symbols.First(s => s.Name == "<x>");
     198        var s_ = grammar.Symbols.First(s => s.Name == "<s>");
     199        var a = grammar.Symbols.First(s => s.Name == "<a>");
     200        var b = grammar.Symbols.First(s => s.Name == "<b>");
     201        var c = grammar.Symbols.First(s => s.Name == "<c>");
     202        var d = grammar.Symbols.First(s => s.Name == "<d>");
     203        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(prs));
     204        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(ss));
     205        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(x));
     206        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(s_));
     207        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(a));
     208        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(b));
     209        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(c));
     210        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(d));
     211      }
     212    }
     213
     214    private static ISymbolicExpressionGrammar CreateTestGrammar1() {
     215      var grammar = new SimpleSymbolicExpressionGrammar();
     216      var x = new SimpleSymbol("<x>", 1);
     217      var z = new SimpleSymbol("<z>", 6);
     218      var a = new SimpleSymbol("<a>", 1);
     219      var b = new SimpleSymbol("<b>", 1);
     220      var c = new SimpleSymbol("<c>", 1);
     221      var d = new SimpleSymbol("<d>", 1);
     222
     223      var _x = new SimpleSymbol("x", 0);
     224      var _y = new SimpleSymbol("y", 0);
     225
     226      grammar.AddSymbol(x);
     227      grammar.AddSymbol(z);
     228      grammar.AddSymbol(a);
     229      grammar.AddSymbol(b);
     230      grammar.AddSymbol(c);
     231      grammar.AddSymbol(d);
     232      grammar.AddSymbol(_x);
     233      grammar.AddSymbol(_y);
     234
     235      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
     236      //uncommenting the line below changes the minimum expression length for the symbol <x>
     237      grammar.AddAllowedChildSymbol(x, z);
     238      grammar.AddAllowedChildSymbol(z, _x);
     239      grammar.AddAllowedChildSymbol(x, a);
     240      grammar.AddAllowedChildSymbol(a, b);
     241      grammar.AddAllowedChildSymbol(b, c);
     242      grammar.AddAllowedChildSymbol(c, d);
     243      grammar.AddAllowedChildSymbol(d, _y);
     244
     245      return grammar;
     246    }
     247
     248    private static ISymbolicExpressionGrammar CreateTestGrammar2() {
     249      var grammar = new SimpleSymbolicExpressionGrammar();
     250      var x = new SimpleSymbol("<x>", 2);
     251      var z = new SimpleSymbol("<z>", 6);
     252      var a = new SimpleSymbol("<a>", 1);
     253      var b = new SimpleSymbol("<b>", 1);
     254      var c = new SimpleSymbol("<c>", 1);
     255      var d = new SimpleSymbol("<d>", 1);
     256
     257      var _x = new SimpleSymbol("x", 0);
     258      var _y = new SimpleSymbol("y", 0);
     259
     260      grammar.AddSymbol(x);
     261      grammar.AddSymbol(z);
     262      grammar.AddSymbol(a);
     263      grammar.AddSymbol(b);
     264      grammar.AddSymbol(c);
     265      grammar.AddSymbol(d);
     266      grammar.AddSymbol(_x);
     267      grammar.AddSymbol(_y);
     268
     269      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
     270      //uncommenting the line below changes the minimum expression length for the symbol <x>
     271      grammar.AddAllowedChildSymbol(x, z);
     272      grammar.AddAllowedChildSymbol(z, _x);
     273      grammar.AddAllowedChildSymbol(x, a);
     274      grammar.AddAllowedChildSymbol(a, b);
     275      grammar.AddAllowedChildSymbol(b, c);
     276      grammar.AddAllowedChildSymbol(c, d);
     277      grammar.AddAllowedChildSymbol(d, _y);
     278
     279      return grammar;
     280    }
     281
     282    private static ISymbolicExpressionGrammar CreateTestGrammar3() {
     283      var grammar = new SimpleSymbolicExpressionGrammar();
     284      var x = new SimpleSymbol("<x>", 1);
     285
     286      grammar.AddSymbol(x);
     287
     288      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
     289      grammar.AddAllowedChildSymbol(x, x);
     290      return grammar;
     291    }
     292
     293
     294    private static ISymbolicExpressionGrammar CreateTestGrammar4() {
     295      var grammar = new SimpleSymbolicExpressionGrammar();
     296      var x = new SimpleSymbol("<x>", 1);
     297      var y = new SimpleSymbol("<y>", 1);
     298
     299      grammar.AddSymbol(x);
     300      grammar.AddSymbol(y);
     301
     302      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
     303      grammar.AddAllowedChildSymbol(x, x);
     304      grammar.AddAllowedChildSymbol(x, y);
     305      grammar.AddAllowedChildSymbol(y, x);
     306      grammar.AddAllowedChildSymbol(y, y);
     307      return grammar;
     308    }
     309
     310    private static ISymbolicExpressionGrammar CreateTestGrammar5() {
     311      var grammar = new SimpleSymbolicExpressionGrammar();
     312      var x = new SimpleSymbol("<x>", 1);
     313      var y = new SimpleSymbol("<y>", 1);
     314      var _x = new SimpleSymbol("x", 0);
     315
     316      grammar.AddSymbol(x);
     317      grammar.AddSymbol(y);
     318      grammar.AddSymbol(_x);
     319
     320      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
     321      grammar.AddAllowedChildSymbol(x, x);
     322      grammar.AddAllowedChildSymbol(x, y);
     323      grammar.AddAllowedChildSymbol(y, x);
     324      grammar.AddAllowedChildSymbol(y, y);
     325      grammar.AddAllowedChildSymbol(y, _x);
     326      return grammar;
     327    }
     328
     329    private static ISymbolicExpressionGrammar CreateTestGrammar6() {
    59330      var grammar = new SimpleSymbolicExpressionGrammar();
    60331      var x = new SimpleSymbol("<x>", 1);
Note: See TracChangeset for help on using the changeset viewer.