Index: trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleRSquaredEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleRSquaredEvaluator.cs	(revision 5396)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleRSquaredEvaluator.cs	(revision 5412)
@@ -71,8 +71,4 @@
       }
     }
-
-    private static bool IsInvalidValue(double d) {
-      return double.IsNaN(d) || double.IsInfinity(d);
-    }
   }
 }
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/SimpleArithmeticExpressionInterpreterTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/SimpleArithmeticExpressionInterpreterTest.cs	(revision 5396)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/SimpleArithmeticExpressionInterpreterTest.cs	(revision 5412)
@@ -40,7 +40,4 @@
     private const int Rows = 1000;
     private const int Columns = 50;
-    private static SymbolicExpressionTree[] randomTrees;
-    private static Dataset dataset;
-    private static MersenneTwister twister;
     private TestContext testContextInstance;
 
@@ -58,8 +55,8 @@
     }
 
-    [ClassInitialize()]
-    public static void CreateRandomTrees(TestContext testContext) {
-      twister = new MersenneTwister();
-      dataset = Util.CreateRandomDataset(twister, Rows, Columns);
+    [TestMethod]
+    public void FullGrammarSimpleArithmeticExpressionInterpreterPerformanceTest() {
+      var twister = new MersenneTwister();
+      var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
       var grammar = new GlobalSymbolicExpressionGrammar(new FullFunctionalExpressionGrammar());
       grammar.MaxFunctionArguments = 0;
@@ -67,9 +64,5 @@
       grammar.MinFunctionArguments = 0;
       grammar.MinFunctionDefinitions = 0;
-      randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
-    }
-
-    [TestMethod]
-    public void SimpleArithmeticExpressionInterpreterPerformanceTest() {
+      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
       double[] estimation = new double[Rows];
       foreach (SymbolicExpressionTree tree in randomTrees) {
@@ -77,5 +70,25 @@
       }
       SimpleArithmeticExpressionInterpreter interpreter = new SimpleArithmeticExpressionInterpreter();
-      Util.EvaluateTrees(randomTrees, interpreter, dataset, 10);
+      double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
+      Assert.IsTrue(nodesPerSec > 15.0e6); // evaluated nodes per seconds must be larger than 15mNodes/sec
+    }
+
+    [TestMethod]
+    public void ArithmeticGrammarSimpleArithmeticExpressionInterpreterPerformanceTest() {
+      var twister = new MersenneTwister();
+      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 randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
+      double[] estimation = new double[Rows];
+      foreach (SymbolicExpressionTree tree in randomTrees) {
+        Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
+      }
+      SimpleArithmeticExpressionInterpreter interpreter = new SimpleArithmeticExpressionInterpreter();
+      double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
+      Assert.IsTrue(nodesPerSec > 15.0e6); // evaluated nodes per seconds must be larger than 15mNodes/sec
     }
 
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/Util.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/Util.cs	(revision 5396)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/Util.cs	(revision 5412)
@@ -29,4 +29,6 @@
 using HeuristicLab.Random;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Problems.DataAnalysis.Evaluators;
+using System;
 namespace HeuristicLab.Problems.DataAnalysis.Tests {
   internal class Util {
@@ -80,24 +82,27 @@
     }
 
-    public static void EvaluateTrees(SymbolicExpressionTree[] trees, ISymbolicExpressionTreeInterpreter interpreter, Dataset dataset, int repetitions) {
-      double[] estimation = new double[dataset.Rows];
+    public static double CalculateEvaluatedNodesPerSec(SymbolicExpressionTree[] trees, ISymbolicExpressionTreeInterpreter interpreter, Dataset dataset, int repetitions) {
       // warm up
+      IEnumerable<int> rows = Enumerable.Range(0, dataset.Rows);
+      long nNodes = 0;
+      double c = 0;
       for (int i = 0; i < trees.Length; i++) {
-        estimation = interpreter.GetSymbolicExpressionTreeValues(trees[i], dataset, Enumerable.Range(0, dataset.Rows)).ToArray();
+        nNodes += trees[i].Size * (dataset.Rows - 1);
+        c = interpreter.GetSymbolicExpressionTreeValues(trees[i], dataset, rows).Count(); // count needs to evaluate all rows
       }
 
       Stopwatch watch = new Stopwatch();
-      long nNodes = 0;
       for (int rep = 0; rep < repetitions; rep++) {
         watch.Start();
+        c = 0;
         for (int i = 0; i < trees.Length; i++) {
-          nNodes += trees[i].Size * (dataset.Rows - 1);
-          estimation = interpreter.GetSymbolicExpressionTreeValues(trees[i], dataset, Enumerable.Range(0, dataset.Rows)).ToArray();
+          interpreter.GetSymbolicExpressionTreeValues(trees[i], dataset, rows).Count(); // count needs to evaluate all rows
         }
         watch.Stop();
       }
-      Assert.Inconclusive("Random tree evaluation performance of " + interpreter.GetType() + ":" +
+      Console.WriteLine("Random tree evaluation performance of " + interpreter.GetType() + ": " +
         watch.ElapsedMilliseconds + "ms " +
-        Util.NodesPerSecond(nNodes, watch) + " nodes/sec");
+        Util.NodesPerSecond(nNodes * repetitions, watch) + " nodes/sec");
+      return Util.NodesPerSecond(nNodes * repetitions, watch);
     }
   }
