Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4/GrammarsTest.cs @ 14354

Last change on this file since 14354 was 14354, checked in by bburlacu, 8 years ago

#2685: Revert accidental commit.
File size: 11.2 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System.Linq;
23using Microsoft.VisualStudio.TestTools.UnitTesting;
24
25namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Tests {
26  [TestClass]
27  public class GrammarsTest {
28    [TestMethod]
29    [TestCategory("Encodings.SymbolicExpressionTree")]
30    [TestProperty("Time", "short")]
31    public void MinimumExpressionLengthTest() {
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    [TestMethod]
92    [TestCategory("Encodings.SymbolicExpressionTree")]
93    [TestProperty("Time", "short")]
94    public void MinimumExpressionDepthTest() {
95      {
96        var grammar = CreateTestGrammar1();
97
98        var prs = grammar.ProgramRootSymbol;
99        var ss = grammar.StartSymbol;
100        var a = grammar.Symbols.First(s => s.Name == "<a>");
101        var b = grammar.Symbols.First(s => s.Name == "<b>");
102        var c = grammar.Symbols.First(s => s.Name == "<c>");
103        var d = grammar.Symbols.First(s => s.Name == "<d>");
104        var x = grammar.Symbols.First(s => s.Name == "x");
105        var y = grammar.Symbols.First(s => s.Name == "y");
106
107        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(prs));
108        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(ss));
109        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(a));
110        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(b));
111        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(c));
112        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(d));
113        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(x));
114        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(y));
115      }
116
117      {
118        var grammar = CreateTestGrammar2();
119
120        var prs = grammar.ProgramRootSymbol;
121        var ss = grammar.StartSymbol;
122        var a = grammar.Symbols.First(s => s.Name == "<a>");
123        var b = grammar.Symbols.First(s => s.Name == "<b>");
124        var c = grammar.Symbols.First(s => s.Name == "<c>");
125        var d = grammar.Symbols.First(s => s.Name == "<d>");
126        var x = grammar.Symbols.First(s => s.Name == "x");
127        var y = grammar.Symbols.First(s => s.Name == "y");
128
129        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(prs));
130        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(ss));
131        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(a));
132        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(b));
133        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(c));
134        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(d));
135        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(x));
136        Assert.AreEqual(1, grammar.GetMinimumExpressionDepth(y));
137      }
138
139      {
140        var grammar = CreateTestGrammar3();
141        var prs = grammar.ProgramRootSymbol;
142        var ss = grammar.StartSymbol;
143        var x = grammar.Symbols.First(s => s.Name == "<x>");
144        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(prs));
145        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(ss));
146        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(x));
147      }
148
149      {
150        var grammar = CreateTestGrammar4();
151        var prs = grammar.ProgramRootSymbol;
152        var ss = grammar.StartSymbol;
153        var x = grammar.Symbols.First(s => s.Name == "<x>");
154        var y = grammar.Symbols.First(s => s.Name == "<y>");
155        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(prs));
156        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(ss));
157        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(x));
158        Assert.AreEqual(int.MaxValue, grammar.GetMinimumExpressionDepth(y));
159      }
160
161      {
162        var grammar = CreateTestGrammar5();
163        var prs = grammar.ProgramRootSymbol;
164        var ss = grammar.StartSymbol;
165        var x = grammar.Symbols.First(s => s.Name == "<x>");
166        var y = grammar.Symbols.First(s => s.Name == "<y>");
167        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(prs));
168        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(ss));
169        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(x));
170        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(y));
171      }
172    }
173
174    private static ISymbolicExpressionGrammar CreateTestGrammar1() {
175      var grammar = new SimpleSymbolicExpressionGrammar();
176      var x = new SimpleSymbol("<x>", 1);
177      var z = new SimpleSymbol("<z>", 6);
178      var a = new SimpleSymbol("<a>", 1);
179      var b = new SimpleSymbol("<b>", 1);
180      var c = new SimpleSymbol("<c>", 1);
181      var d = new SimpleSymbol("<d>", 1);
182
183      var _x = new SimpleSymbol("x", 0);
184      var _y = new SimpleSymbol("y", 0);
185
186      grammar.AddSymbol(x);
187      grammar.AddSymbol(z);
188      grammar.AddSymbol(a);
189      grammar.AddSymbol(b);
190      grammar.AddSymbol(c);
191      grammar.AddSymbol(d);
192      grammar.AddSymbol(_x);
193      grammar.AddSymbol(_y);
194
195      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
196      //uncommenting the line below changes the minimum expression length for the symbol <x>
197      grammar.AddAllowedChildSymbol(x, z);
198      grammar.AddAllowedChildSymbol(z, _x);
199      grammar.AddAllowedChildSymbol(x, a);
200      grammar.AddAllowedChildSymbol(a, b);
201      grammar.AddAllowedChildSymbol(b, c);
202      grammar.AddAllowedChildSymbol(c, d);
203      grammar.AddAllowedChildSymbol(d, _y);
204
205      return grammar;
206    }
207
208    private static ISymbolicExpressionGrammar CreateTestGrammar2() {
209      var grammar = new SimpleSymbolicExpressionGrammar();
210      var x = new SimpleSymbol("<x>", 2);
211      var z = new SimpleSymbol("<z>", 6);
212      var a = new SimpleSymbol("<a>", 1);
213      var b = new SimpleSymbol("<b>", 1);
214      var c = new SimpleSymbol("<c>", 1);
215      var d = new SimpleSymbol("<d>", 1);
216
217      var _x = new SimpleSymbol("x", 0);
218      var _y = new SimpleSymbol("y", 0);
219
220      grammar.AddSymbol(x);
221      grammar.AddSymbol(z);
222      grammar.AddSymbol(a);
223      grammar.AddSymbol(b);
224      grammar.AddSymbol(c);
225      grammar.AddSymbol(d);
226      grammar.AddSymbol(_x);
227      grammar.AddSymbol(_y);
228
229      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
230      //uncommenting the line below changes the minimum expression length for the symbol <x>
231      grammar.AddAllowedChildSymbol(x, z);
232      grammar.AddAllowedChildSymbol(z, _x);
233      grammar.AddAllowedChildSymbol(x, a);
234      grammar.AddAllowedChildSymbol(a, b);
235      grammar.AddAllowedChildSymbol(b, c);
236      grammar.AddAllowedChildSymbol(c, d);
237      grammar.AddAllowedChildSymbol(d, _y);
238
239      return grammar;
240    }
241
242    private static ISymbolicExpressionGrammar CreateTestGrammar3() {
243      var grammar = new SimpleSymbolicExpressionGrammar();
244      var x = new SimpleSymbol("<x>", 1);
245
246      grammar.AddSymbol(x);
247
248      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
249      grammar.AddAllowedChildSymbol(x, x);
250      return grammar;
251    }
252
253
254    private static ISymbolicExpressionGrammar CreateTestGrammar4() {
255      var grammar = new SimpleSymbolicExpressionGrammar();
256      var x = new SimpleSymbol("<x>", 1);
257      var y = new SimpleSymbol("<y>", 1);
258
259      grammar.AddSymbol(x);
260      grammar.AddSymbol(y);
261
262      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
263      grammar.AddAllowedChildSymbol(x, x);
264      grammar.AddAllowedChildSymbol(x, y);
265      grammar.AddAllowedChildSymbol(y, x);
266      grammar.AddAllowedChildSymbol(y, y);
267      return grammar;
268    }
269
270    private static ISymbolicExpressionGrammar CreateTestGrammar5() {
271      var grammar = new SimpleSymbolicExpressionGrammar();
272      var x = new SimpleSymbol("<x>", 1);
273      var y = new SimpleSymbol("<y>", 1);
274      var _x = new SimpleSymbol("x", 0);
275
276      grammar.AddSymbol(x);
277      grammar.AddSymbol(y);
278      grammar.AddSymbol(_x);
279
280      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
281      grammar.AddAllowedChildSymbol(x, x);
282      grammar.AddAllowedChildSymbol(x, y);
283      grammar.AddAllowedChildSymbol(y, x);
284      grammar.AddAllowedChildSymbol(y, y);
285      grammar.AddAllowedChildSymbol(y, _x);
286      return grammar;
287    }
288  }
289}
Note: See TracBrowser for help on using the repository browser.