Free cookie consent management tool by TermsFeed Policy Generator

source: branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Util.cs @ 5733

Last change on this file since 5733 was 5733, checked in by mkommend, 13 years ago

#1418: Corrected problem interfaces & unified naming of subtrees.

File size: 7.9 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2011 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;
23using System.Collections.Generic;
24using System.Linq;
25using System.Text;
26using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
27using Microsoft.VisualStudio.TestTools.UnitTesting;
28
29namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding_3._4.Tests {
30  public static class Util {
31    public static string GetSizeDistributionString(IList<ISymbolicExpressionTree> trees, int maxTreeLength, int binSize) {
32      int[] histogram = new int[maxTreeLength / binSize];
33      for (int i = 0; i < trees.Count; i++) {
34        int binIndex = Math.Min(histogram.Length - 1, trees[i].Length / binSize);
35        histogram[binIndex]++;
36      }
37      StringBuilder strBuilder = new StringBuilder();
38      for (int i = 0; i < histogram.Length - 1; i++) {
39        strBuilder.Append(Environment.NewLine);
40        strBuilder.Append("< "); strBuilder.Append((i + 1) * binSize);
41        strBuilder.Append(": "); strBuilder.AppendFormat("{0:#0.00%}", histogram[i] / (double)trees.Count);
42      }
43      strBuilder.Append(Environment.NewLine);
44      strBuilder.Append(">= "); strBuilder.Append(histogram.Length * binSize);
45      strBuilder.Append(": "); strBuilder.AppendFormat("{0:#0.00%}", histogram[histogram.Length - 1] / (double)trees.Count);
46
47      return "Size distribution: " + strBuilder;
48    }
49
50    public static string GetFunctionDistributionString(IList<ISymbolicExpressionTree> trees) {
51      Dictionary<string, int> occurances = new Dictionary<string, int>();
52      double n = 0.0;
53      for (int i = 0; i < trees.Count; i++) {
54        foreach (var node in trees[i].IterateNodesPrefix()) {
55          if (node.Subtrees.Count() > 0) {
56            if (!occurances.ContainsKey(node.Symbol.Name))
57              occurances[node.Symbol.Name] = 0;
58            occurances[node.Symbol.Name]++;
59            n++;
60          }
61        }
62      }
63      StringBuilder strBuilder = new StringBuilder();
64      foreach (var function in occurances.Keys) {
65        strBuilder.Append(Environment.NewLine);
66        strBuilder.Append(function); strBuilder.Append(": ");
67        strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
68      }
69      return "Function distribution: " + strBuilder;
70    }
71
72    public static string GetNumberOfSubtreesDistributionString(IList<ISymbolicExpressionTree> trees) {
73      Dictionary<int, int> occurances = new Dictionary<int, int>();
74      double n = 0.0;
75      for (int i = 0; i < trees.Count; i++) {
76        foreach (var node in trees[i].IterateNodesPrefix()) {
77          if (!occurances.ContainsKey(node.Subtrees.Count()))
78            occurances[node.Subtrees.Count()] = 0;
79          occurances[node.Subtrees.Count()]++;
80          n++;
81        }
82      }
83      StringBuilder strBuilder = new StringBuilder();
84      foreach (var arity in occurances.Keys) {
85        strBuilder.Append(Environment.NewLine);
86        strBuilder.Append(arity); strBuilder.Append(": ");
87        strBuilder.AppendFormat("{0:#0.00%}", occurances[arity] / n);
88      }
89      return "Distribution of function arities: " + strBuilder;
90    }
91
92
93    public static string GetTerminalDistributionString(IList<ISymbolicExpressionTree> trees) {
94      Dictionary<string, int> occurances = new Dictionary<string, int>();
95      double n = 0.0;
96      for (int i = 0; i < trees.Count; i++) {
97        foreach (var node in trees[i].IterateNodesPrefix()) {
98          if (node.Subtrees.Count() == 0) {
99            if (!occurances.ContainsKey(node.Symbol.Name))
100              occurances[node.Symbol.Name] = 0;
101            occurances[node.Symbol.Name]++;
102            n++;
103          }
104        }
105      }
106      StringBuilder strBuilder = new StringBuilder();
107      foreach (var function in occurances.Keys) {
108        strBuilder.Append(Environment.NewLine);
109        strBuilder.Append(function); strBuilder.Append(": ");
110        strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
111      }
112      return "Terminal distribution: " + strBuilder;
113    }
114
115    public static void IsValid(ISymbolicExpressionTree tree) {
116      int reportedSize = tree.Length;
117      int actualSize = tree.IterateNodesPostfix().Count();
118      Assert.AreEqual(actualSize, reportedSize);
119
120      foreach (var defunTreeNode in tree.Root.Subtrees.OfType<DefunTreeNode>()) {
121        int arity = defunTreeNode.NumberOfArguments;
122
123        foreach (var argTreenode in defunTreeNode.IterateNodesPrefix().OfType<ArgumentTreeNode>()) {
124          Assert.IsTrue(argTreenode.SubtreesCount == 0);
125          Assert.IsTrue(((Argument)argTreenode.Symbol).ArgumentIndex < arity);
126        }
127
128        foreach (var argSymbol in Enumerable.Range(0, defunTreeNode.NumberOfArguments).Select(x => new Argument(x))) {
129          Assert.IsTrue(defunTreeNode.Grammar.ContainsSymbol(argSymbol));
130          Assert.IsTrue(defunTreeNode.Grammar.GetMaximumSubtreeCount(argSymbol) == 0);
131          Assert.IsTrue(defunTreeNode.Grammar.GetMinimumSubtreeCount(argSymbol) == 0);
132        }
133
134        var invoke = new InvokeFunction(defunTreeNode.FunctionName);
135        foreach (var otherRootNode in tree.Root.Subtrees) {
136          if (otherRootNode.Grammar.ContainsSymbol(invoke)) {
137            Assert.IsTrue(otherRootNode.Grammar.GetMinimumSubtreeCount(invoke) == arity);
138            Assert.IsTrue(otherRootNode.Grammar.GetMaximumSubtreeCount(invoke) == arity);
139          }
140        }
141
142      }
143      foreach (var subtree in tree.Root.Subtrees) {
144        Assert.AreNotSame(subtree.Grammar, tree.Root.Grammar);
145        IsValid(subtree.Grammar);
146      }
147
148      IsValid(tree.Root.Grammar);
149      IsValid(tree.Root);
150    }
151
152    public static void IsValid(ISymbolicExpressionTreeGrammar grammar) {
153      Assert.IsTrue(grammar.Symbols.Count() == grammar.Symbols.Distinct().Count());
154      foreach (ISymbol symbol in grammar.Symbols) {
155        Assert.IsTrue(grammar.GetMinimumSubtreeCount(symbol) <= grammar.GetMaximumExpressionLength(symbol));
156        Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol).Count() == grammar.GetAllowedChildSymbols(symbol).Distinct().Count());
157        for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++) {
158          Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Count() == grammar.GetAllowedChildSymbols(symbol, i).Distinct().Count());
159        }
160      }
161    }
162
163    public static void IsValid(ISymbolicExpressionTreeNode treeNode) {
164      var matchingSymbol = (from symb in treeNode.Grammar.Symbols
165                            where symb.Name == treeNode.Symbol.Name
166                            select symb).SingleOrDefault();
167      Assert.IsTrue(treeNode.Subtrees.Count() >= treeNode.Grammar.GetMinimumSubtreeCount(matchingSymbol));
168      Assert.IsTrue(treeNode.Subtrees.Count() <= treeNode.Grammar.GetMaximumSubtreeCount(matchingSymbol));
169      Assert.AreNotEqual(0.0, matchingSymbol.InitialFrequency); // check that no deactivated symbols occur in the tree
170      for (int i = 0; i < treeNode.Subtrees.Count(); i++) {
171        Assert.IsTrue(treeNode.Grammar.GetAllowedChildSymbols(treeNode.Symbol, i).Select(x => x.Name).Contains(treeNode.GetSubtree(i).Symbol.Name));
172        IsValid(treeNode.GetSubtree(i));
173      }
174    }
175  }
176}
Note: See TracBrowser for help on using the repository browser.