Index: branches/HeuristicLab.Problems.GrammaticalOptimization/Test/TestSymbRegInstances.cs
===================================================================
--- branches/HeuristicLab.Problems.GrammaticalOptimization/Test/TestSymbRegInstances.cs	(revision 12024)
+++ branches/HeuristicLab.Problems.GrammaticalOptimization/Test/TestSymbRegInstances.cs	(revision 12025)
@@ -32,12 +32,13 @@
 
     [TestMethod]
+    [Timeout(1000 * 60 * 60 * 8)] // 8 hours
     public void TestSequentialSolverForTower() {
       var problem = new SymbolicRegressionProblem(new Random(), "Tower");
       var random = new Random(31415);
-      var solver = new SequentialSearch(problem, 30, random, 0, new GenericGrammarPolicy(problem, new UCB1TunedPolicy(), true));
+      var solver = new SequentialSearch(problem, 50, random, 0, new GenericFunctionApproximationGrammarPolicy(problem, true));
       solver.FoundNewBestSolution += (s, d) => {
         Console.WriteLine("{0:F3} {1}", d, s);
       };
-      solver.Run(100);
+      solver.Run(100000);
     }
 
Index: branches/HeuristicLab.Problems.GrammaticalOptimization/Test/TestTunedSettings.cs
===================================================================
--- branches/HeuristicLab.Problems.GrammaticalOptimization/Test/TestTunedSettings.cs	(revision 12024)
+++ branches/HeuristicLab.Problems.GrammaticalOptimization/Test/TestTunedSettings.cs	(revision 12025)
@@ -11,4 +11,5 @@
 using HeuristicLab.Algorithms.GrammaticalOptimization;
 using HeuristicLab.Common;
+using HeuristicLab.Problems.GrammaticalOptimization.SymbReg;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using RandomPolicy = HeuristicLab.Algorithms.Bandits.BanditPolicies.RandomPolicy;
@@ -28,6 +29,7 @@
     }
     [TestMethod]
+    [Timeout(1000 * 60 * 60 * 12)] // 12 hours
     // this configuration worked especially well in the experiments
-    public void TestThresholdAscentArtificialAnt() {
+    public void TestAllPoliciesArtificialAnt() {
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
 
@@ -40,5 +42,5 @@
         {
          () => new RandomPolicy(), 
-          () => new ActiveLearningPolicy(),  
+         () => new ActiveLearningPolicy(),  
          () => new EpsGreedyPolicy(0.01, (aInfo)=> aInfo.MaxReward, "max"), 
          () => new EpsGreedyPolicy(0.05, (aInfo)=> aInfo.MaxReward, "max"), 
@@ -81,8 +83,8 @@
          () => new BoltzmannExplorationPolicy(200),
          () => new BoltzmannExplorationPolicy(500),
-          () => new ChernoffIntervalEstimationPolicy( 0.01), 
-          () => new ChernoffIntervalEstimationPolicy( 0.05),
-          () => new ChernoffIntervalEstimationPolicy( 0.1),
-          () => new ChernoffIntervalEstimationPolicy( 0.2),
+         () => new ChernoffIntervalEstimationPolicy( 0.01), 
+         () => new ChernoffIntervalEstimationPolicy( 0.05),
+         () => new ChernoffIntervalEstimationPolicy( 0.1),
+         () => new ChernoffIntervalEstimationPolicy( 0.2),
          () => new ThresholdAscentPolicy(5, 0.01), 
          () => new ThresholdAscentPolicy(5, 0.05),
@@ -110,5 +112,5 @@
       var maxSizes = new int[] { 17 };  // necessary size for ant programm
       int nReps = 20;
-      int maxIterations = 20000;
+      int maxIterations = 100000;
       foreach (var instanceFactory in instanceFactories) {
         var sumBestQ = 0.0;
@@ -135,5 +137,83 @@
         // Assert.AreEqual(5461.7, sumItersToBest / (double)nReps, 1E-6);
       }
-
+    }
+
+
+    [TestMethod]
+    [Timeout(1000 * 60 * 60 * 12)] // 12 hours
+    // this configuration worked especially well in the experiments
+    public void TestPoly10WithOutConstantOpt() {
+      CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
+
+      var instanceFactories = new Func<int, ISymbolicExpressionTreeProblem>[]
+      {
+        (randSeed) => (ISymbolicExpressionTreeProblem)new SymbolicRegressionPoly10Problem(), 
+      };
+
+      var maxSizes = new int[] { 23 };  
+      int nReps = 20;
+      int maxIterations = 100000;
+      foreach (var instanceFactory in instanceFactories) {
+        var sumBestQ = 0.0;
+        var sumItersToBest = 0;
+        double fractionSolved = 0.0;
+        foreach (var conf in GenerateConfigurations(instanceFactory, nReps, maxSizes)) {
+          var prob = conf.Problem;
+          var maxLen = conf.MaxSize;
+          var rand = new Random(conf.RandSeed);
+
+          var solver = new SequentialSearch(prob, maxLen, rand, 0,
+            new GenericFunctionApproximationGrammarPolicy(prob, true));
+
+          var problemName = prob.GetType().Name;
+          double bestQ; int itersToBest;
+          RunSolver(solver, problemName, string.Empty, 1.0, maxIterations, maxLen, out bestQ, out itersToBest);
+          sumBestQ += bestQ;
+          sumItersToBest += itersToBest;
+          if (bestQ.IsAlmost(1.0)) fractionSolved += 1.0 / nReps;
+        }
+        // Assert.AreEqual(0.85, fractionSolved, 1E-6);
+        // Assert.AreEqual(0.99438202247191, sumBestQ / nReps, 1E-6);
+        // Assert.AreEqual(5461.7, sumItersToBest / (double)nReps, 1E-6);
+      }
+    }
+
+    [TestMethod]
+    [Timeout(1000 * 60 * 60 * 12)] // 12 hours
+    // this configuration worked especially well in the experiments
+    public void TestPoly10WithConstantOpt() {
+      CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
+
+      var instanceFactories = new Func<int, ISymbolicExpressionTreeProblem>[]
+      {
+        (randSeed) => (ISymbolicExpressionTreeProblem)new SymbolicRegressionProblem(new Random(randSeed), "Poly-10", true ), 
+      };
+
+      var maxSizes = new int[] { 23 };  
+      int nReps = 20;
+      int maxIterations = 100000;
+      foreach (var instanceFactory in instanceFactories) {
+        var sumBestQ = 0.0;
+        var sumItersToBest = 0;
+        double fractionSolved = 0.0;
+        foreach (var conf in GenerateConfigurations(instanceFactory, nReps, maxSizes)) {
+          var prob = conf.Problem;
+          var maxLen = conf.MaxSize;
+          var rand = new Random(conf.RandSeed);
+
+          var solver = new SequentialSearch(prob, maxLen, rand, 0,
+            new GenericFunctionApproximationGrammarPolicy(prob, true));
+
+          var problemName = prob.GetType().Name;
+          double bestQ; int itersToBest;
+          RunSolver(solver, problemName, string.Empty, 1.0, maxIterations, maxLen, out bestQ, out itersToBest);
+          sumBestQ += bestQ;
+          sumItersToBest += itersToBest;
+          if (bestQ.IsAlmost(1.0)) fractionSolved += 1.0 / nReps;
+        }
+        // Assert.AreEqual(0.85, fractionSolved, 1E-6);
+        // Assert.AreEqual(0.99438202247191, sumBestQ / nReps, 1E-6);
+        // Assert.AreEqual(5461.7, sumItersToBest / (double)nReps, 1E-6);
+      }
     }
 
