Changeset 5686 for branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

03/15/11 13:34:38 (13 years ago)

Author:

mkommend

Message:

#1418: Finally added results from the grammar refactoring.

Location:

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Grammars/ArithmeticExpressionGrammar.cs (modified) (2 diffs)
• Grammars/FullFunctionalExpressionGrammar.cs (modified) (3 diffs)
• Grammars/TypeCoherentExpressionGrammar.cs (modified) (3 diffs)
• Interfaces/ISymbolicDataAnalysisGrammar.cs (modified) (1 diff)
• Tests/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs (modified) (3 diffs)
• Tests/Util.cs (modified) (2 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs

@@ -29 +29 @@
   [StorableClass]
   [Item("ArithmeticExpressionGrammar", "Represents a grammar for functional expressions using only arithmetic operations.")]
-  public class ArithmeticExpressionGrammar : DefaultSymbolicExpressionGrammar, ISymbolicDataAnalysisGrammar {
+  public class ArithmeticExpressionGrammar : SymbolicExpressionGrammar, ISymbolicDataAnalysisGrammar {
 
     [StorableConstructor]
@@ -59 +59 @@
 
       foreach (var funSymb in functionSymbols) {
-        SetMinSubtreeCount(funSymb, 1);
-        SetMaxSubtreeCount(funSymb, 3);
+        SetSubtreeCount(funSymb, 1, 3);
       }
-      SetMinSubtreeCount(constant, 0);
-      SetMaxSubtreeCount(constant, 0);
-      SetMinSubtreeCount(variableSymbol, 0);
-      SetMaxSubtreeCount(variableSymbol, 0);
+      SetSubtreeCount(constant, 0, 0);
+      SetSubtreeCount(variableSymbol, 0, 0);
 
       // allow each symbol as child of the start symbol
       foreach (var symb in allSymbols) {
-        SetAllowedChild(StartSymbol, symb, 0);
+        AddAllowedChildSymbol(StartSymbol, symb);
       }
 
       // allow each symbol as child of every other symbol (except for terminals that have maxSubtreeCount == 0)
-      foreach (var parent in allSymbols) {
-        for (int i = 0; i < GetMaxSubtreeCount(parent); i++)
-          foreach (var child in allSymbols) {
-            SetAllowedChild(parent, child, i);
-          }
+      foreach (var parent in functionSymbols) {
+        foreach (var child in allSymbols)
+          AddAllowedChildSymbol(parent, child);
       }
     }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs

@@ -21 +21 @@
 
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -29 +30 @@
   [StorableClass]
   [Item("FullFunctionalExpressionGrammar", "Represents a grammar for functional expressions using all available functions.")]
-  public class FullFunctionalExpressionGrammar : DefaultSymbolicExpressionGrammar, ISymbolicDataAnalysisGrammar {
+  public class FullFunctionalExpressionGrammar : SymbolicExpressionGrammar, ISymbolicDataAnalysisGrammar {
     [StorableConstructor]
     protected FullFunctionalExpressionGrammar(bool deserializing) : base(deserializing) { }
@@ -92 +93 @@
 
       foreach (var funSymb in functionSymbols) {
-        SetMinSubtreeCount(funSymb, 1);
-        SetMaxSubtreeCount(funSymb, 3);
+        SetSubtreeCount(funSymb, 1, 3);
       }
       foreach (var funSymb in unaryFunctionSymbols) {
-        SetMinSubtreeCount(funSymb, 1);
-        SetMaxSubtreeCount(funSymb, 1);
+        SetSubtreeCount(funSymb, 1, 1);
       }
       foreach (var funSymb in binaryFunctionSymbols) {
-        SetMinSubtreeCount(funSymb, 2);
-        SetMaxSubtreeCount(funSymb, 2);
+        SetSubtreeCount(funSymb, 2, 2);
+      }
+      foreach (var terminalSymbol in terminalSymbols) {
+        SetSubtreeCount(terminalSymbol, 0, 0);
       }
 
-      foreach (var terminalSymbol in terminalSymbols) {
-        SetMinSubtreeCount(terminalSymbol, 0);
-        SetMaxSubtreeCount(terminalSymbol, 0);
-      }
-
-      SetMinSubtreeCount(@if, 3);
-      SetMaxSubtreeCount(@if, 3);
+      SetSubtreeCount(@if, 3, 3);
 
 
       // allow each symbol as child of the start symbol
       foreach (var symb in allSymbols) {
-        SetAllowedChild(StartSymbol, symb, 0);
+        AddAllowedChildSymbol(StartSymbol, symb);
       }
 
       // allow each symbol as child of every other symbol (except for terminals that have maxSubtreeCount == 0)
-      foreach (var parent in allSymbols) {
-        for (int i = 0; i < GetMaxSubtreeCount(parent); i++)
-          foreach (var child in allSymbols) {
-            SetAllowedChild(parent, child, i);
-          }
+      foreach (var parent in allSymbols.Except(terminalSymbols)) {
+        foreach (var child in allSymbols)
+          AddAllowedChildSymbol(parent, child);
       }
     }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs

@@ -29 +29 @@
   [StorableClass]
   [Item("TypeCoherentExpressionGrammar", "Represents a grammar for functional expressions in which special syntactic constraints are enforced so that boolean and real-valued expressions are not mixed.")]
-  public class TypeCoherentExpressionGrammar : DefaultSymbolicExpressionGrammar, ISymbolicDataAnalysisGrammar {
+  public class TypeCoherentExpressionGrammar : SymbolicExpressionGrammar, ISymbolicDataAnalysisGrammar {
 
     [StorableConstructor]
@@ -123 +123 @@
 
       foreach (var unaryFun in unaryFunctionSymbols.Concat(unaryBooleanFunctionSymbols)) {
-        SetMinSubtreeCount(unaryFun, 1);
-        SetMaxSubtreeCount(unaryFun, 1);
+        SetSubtreeCount(unaryFun, 1, 1);
       }
       foreach (var binaryFun in binaryFunctionSymbols.Concat(binaryBooleanFunctionSymbols).Concat(relationalFunctionSymbols)) {
-        SetMinSubtreeCount(binaryFun, 2);
-        SetMaxSubtreeCount(binaryFun, 2);
+        SetSubtreeCount(binaryFun, 2, 2);
       }
 
       foreach (var terminalSymbol in terminalSymbols) {
-        SetMinSubtreeCount(terminalSymbol, 0);
-        SetMaxSubtreeCount(terminalSymbol, 0);
+        SetSubtreeCount(terminalSymbol, 0, 0);
       }
 
-      SetMinSubtreeCount(@if, 3);
-      SetMaxSubtreeCount(@if, 3);
+      SetSubtreeCount(@if, 3, 3);
 
 
       // allow only real-valued expressions as child of the start symbol
       foreach (var symb in realValuedSymbols) {
-        SetAllowedChild(StartSymbol, symb, 0);
+        AddAllowedChildSymbol(StartSymbol, symb);
       }
 
       foreach (var symb in unaryFunctionSymbols) {
         foreach (var childSymb in realValuedSymbols) {
-          SetAllowedChild(symb, childSymb, 0);
+          AddAllowedChildSymbol(symb, childSymb);
         }
       }
@@ -153 +149 @@
       foreach (var symb in binaryFunctionSymbols) {
         foreach (var childSymb in realValuedSymbols) {
-          SetAllowedChild(symb, childSymb, 0);
-          SetAllowedChild(symb, childSymb, 1);
+          AddAllowedChildSymbol(symb, childSymb);
         }
       }
 
       foreach (var childSymb in booleanSymbols) {
-        SetAllowedChild(@if, childSymb, 0);
+        AddAllowedChildSymbol(@if, childSymb, 0);
       }
       foreach (var childSymb in realValuedSymbols) {
-        SetAllowedChild(@if, childSymb, 1);
-        SetAllowedChild(@if, childSymb, 2);
+        AddAllowedChildSymbol(@if, childSymb, 1);
+        AddAllowedChildSymbol(@if, childSymb, 2);
       }
 
       foreach (var symb in relationalFunctionSymbols) {
         foreach (var childSymb in realValuedSymbols) {
-          SetAllowedChild(symb, childSymb, 0);
-          SetAllowedChild(symb, childSymb, 1);
+          AddAllowedChildSymbol(symb, childSymb);
         }
       }
       foreach (var symb in binaryBooleanFunctionSymbols) {
         foreach (var childSymb in booleanSymbols) {
-          SetAllowedChild(symb, childSymb, 0);
-          SetAllowedChild(symb, childSymb, 1);
+          AddAllowedChildSymbol(symb, childSymb);
         }
       }
       foreach (var symb in unaryBooleanFunctionSymbols) {
         foreach (var childSymb in booleanSymbols) {
-          SetAllowedChild(symb, childSymb, 0);
+          AddAllowedChildSymbol(symb, childSymb);
         }
       }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisGrammar.cs

@@ -23 +23 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  public interface ISymbolicDataAnalysisGrammar : ISymbolicExpressionTreeGrammar {
+  public interface ISymbolicDataAnalysisGrammar : ISymbolicExpressionGrammar {
   }
 }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tests/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs

@@ -25 +25 @@
 using System.Linq;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using HeuristicLab.Random;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -59 +58 @@
       var twister = new MersenneTwister(31415);
       var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
-      var grammar = new GlobalSymbolicExpressionGrammar(new FullFunctionalExpressionGrammar());
-      grammar.MaxFunctionArguments = 0;
-      grammar.MaxFunctionDefinitions = 0;
-      grammar.MinFunctionArguments = 0;
-      grammar.MinFunctionDefinitions = 0;
+      var grammar = new FullFunctionalExpressionGrammar();
+      grammar.MaximumFunctionArguments = 0;
+      grammar.MaximumFunctionDefinitions = 0;
+      grammar.MinimumFunctionArguments = 0;
+      grammar.MinimumFunctionDefinitions = 0;
       var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
       double[] estimation = new double[Rows];
@@ -78 +77 @@
       var twister = new MersenneTwister(31415);
       var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
-      var grammar = new GlobalSymbolicExpressionGrammar(new ArithmeticExpressionGrammar());
-      grammar.MaxFunctionArguments = 0;
-      grammar.MaxFunctionDefinitions = 0;
-      grammar.MinFunctionArguments = 0;
-      grammar.MinFunctionDefinitions = 0;
+      var grammar = new ArithmeticExpressionGrammar();
+      grammar.MaximumFunctionArguments = 0;
+      grammar.MaximumFunctionDefinitions = 0;
+      grammar.MinimumFunctionArguments = 0;
+      grammar.MinimumFunctionDefinitions = 0;
       var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
       double[] estimation = new double[Rows];

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tests/Util.cs

@@ -45 +45 @@
 
 
-    public static ISymbolicExpressionTree[] CreateRandomTrees(MersenneTwister twister, Dataset dataset, ISymbolicExpressionTreeGrammar grammar, int popSize) {
+    public static ISymbolicExpressionTree[] CreateRandomTrees(MersenneTwister twister, Dataset dataset, ISymbolicExpressionGrammar grammar, int popSize) {
       return CreateRandomTrees(twister, dataset, grammar, popSize, 1, 200, 3, 3);
     }
 
-    public static ISymbolicExpressionTree[] CreateRandomTrees(MersenneTwister twister, Dataset dataset, ISymbolicExpressionTreeGrammar grammar,
+    public static ISymbolicExpressionTree[] CreateRandomTrees(MersenneTwister twister, Dataset dataset, ISymbolicExpressionGrammar grammar,
       int popSize, int minSize, int maxSize,
       int maxFunctionDefinitions, int maxFunctionArguments) {
@@ -57 +57 @@
       ISymbolicExpressionTree[] randomTrees = new ISymbolicExpressionTree[popSize];
       for (int i = 0; i < randomTrees.Length; i++) {
-        randomTrees[i] = ProbabilisticTreeCreator.Create(twister, grammar, maxSize, 10, maxFunctionDefinitions, maxFunctionArguments);
+        randomTrees[i] = ProbabilisticTreeCreator.Create(twister, grammar, maxSize, 10);
       }
       return randomTrees;