Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SelectionSchemeAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SelectionSchemeAnalyzer.cs	(revision 12892)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SelectionSchemeAnalyzer.cs	(revision 12894)
@@ -61,17 +61,14 @@
       // to make sure the solutions are analyzed on the first application of this operator
       if (updateCounter == null) {
-        updateCounter = new IntValue(updateInterval);
+        updateCounter = new IntValue(0);
         UpdateCounterParameter.ActualValue = updateCounter;
       }
+      updateCounter.Value++;
       //analyze solutions only every 'updateInterval' times
-      if (updateCounter.Value != updateInterval) {
-        updateCounter.Value++;
-        return base.Apply();
-      }
-      updateCounter.Value = 1;
+      if (updateCounter.Value != updateInterval) return base.Apply();
+      updateCounter.Value = 0;
 
       if (PopulationGraph == null)
         return base.Apply();
-
       double selectionRatio = 1;
 
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs	(revision 12892)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs	(revision 12894)
@@ -80,111 +80,103 @@
     }
 
-    public override void ClearState() {
-      base.ClearState();
-      UpdateCounter.Value = 0;
-    }
-
     public override IOperation Apply() {
-      int updateInterval = UpdateIntervalParameter.Value.Value;
       IntValue updateCounter = UpdateCounterParameter.ActualValue;
       if (updateCounter == null) {
-        updateCounter = new IntValue(updateInterval);
+        updateCounter = new IntValue(0);
         UpdateCounterParameter.ActualValue = updateCounter;
-      } else updateCounter.Value++;
+      }
+      updateCounter.Value++;
+      if (updateCounter.Value != UpdateInterval.Value) return base.Apply();
+      updateCounter.Value = 0;
 
-      if (updateCounter.Value == updateInterval) {
-        updateCounter.Value = 0;
+      var graph = PopulationGraph;
+      if (graph == null || Generation.Value == 0)
+        return base.Apply();
 
-        var graph = PopulationGraph;
-        if (graph == null || Generation.Value == 0)
-          return base.Apply();
+      var generation = Generation.Value;
+      var averageQuality = QualityParameter.ActualValue.Average(x => x.Value);
+      var population = PopulationParameter.ActualValue;
+      var populationSize = population.Length;
 
-        var generation = Generation.Value;
-        var averageQuality = QualityParameter.ActualValue.Average(x => x.Value);
-        var population = PopulationParameter.ActualValue;
-        var populationSize = population.Length;
+      var vertices = population.Select(graph.GetByContent).ToList();
+      DataTable table;
+      double aac = 0; // ratio of above average children produced
+      double aacp = 0; // ratio of above average children from above average parents
+      #region crossover improvement
+      if (!Results.ContainsKey("Crossover improvement")) {
+        table = new DataTable("Crossover improvement");
+        Results.Add(new Result("Crossover improvement", table));
+        table.Rows.AddRange(new[]
+          {
+              new DataRow("Average crossover improvement (root parent)") { VisualProperties = { StartIndexZero = true } },
+              new DataRow("Average crossover improvement (non-root parent)") { VisualProperties = { StartIndexZero = true } },
+              new DataRow("Average child-parents quality difference") { VisualProperties = { StartIndexZero = true } },
+              new DataRow("Best crossover improvement (root parent)") { VisualProperties = { StartIndexZero = true } },
+              new DataRow("Best crossover improvement (non-root parent)") { VisualProperties = { StartIndexZero = true }},
+              new DataRow("Above average children") { VisualProperties = { StartIndexZero = true }},
+              new DataRow("Above average children from above average parents") { VisualProperties = { StartIndexZero = true } },
+            });
+      } else {
+        table = (DataTable)Results["Crossover improvement"].Value;
+      }
+      var crossoverChildren = vertices.Where(x => x.InDegree == 2).ToList();
+      if (CountIntermediateChildren)
+        crossoverChildren.AddRange(vertices.Where(x => x.InDegree == 1).Select(v => v.Parents.First()).Where(p => p.Rank.IsAlmost(generation - 0.5))); // add intermediate children
 
-        var vertices = population.Select(graph.GetByContent).ToList();
-        DataTable table;
-        double aac = 0; // ratio of above average children produced
-        double aacp = 0; // ratio of above average children from above average parents
-        #region crossover improvement
-        if (!Results.ContainsKey("Crossover improvement")) {
-          table = new DataTable("Crossover improvement");
-          Results.Add(new Result("Crossover improvement", table));
-          table.Rows.AddRange(
-            new[]
-            {
-              new DataRow("Average crossover improvement (root parent)") {VisualProperties = {StartIndexZero = true}},
-              new DataRow("Average crossover improvement (non-root parent)") {VisualProperties = {StartIndexZero = true}},
-              new DataRow("Average child-parents quality difference") {VisualProperties = {StartIndexZero = true}},
-              new DataRow("Best crossover improvement (root parent)") {VisualProperties = {StartIndexZero = true}},
-              new DataRow("Best crossover improvement (non-root parent)") {VisualProperties = {StartIndexZero = true}},
-              new DataRow("Above average children") {VisualProperties = {StartIndexZero = true}},
-              new DataRow("Above average children from above average parents") {VisualProperties = {StartIndexZero = true}},
-            });
-        } else {
-          table = (DataTable)Results["Crossover improvement"].Value;
-        }
-        var crossoverChildren = vertices.Where(x => x.InDegree == 2).ToList();
-        if (CountIntermediateChildren)
-          crossoverChildren.AddRange(vertices.Where(x => x.InDegree == 1).Select(v => v.Parents.First()).Where(p => p.Rank.IsAlmost(generation - 0.5))); // add intermediate children
-
-        foreach (var c in crossoverChildren) {
-          if (c.Quality > averageQuality) {
-            aac++;
-            if (c.Parents.All(x => x.Quality > averageQuality))
-              aacp++;
-          }
-        }
-        var avgRootParentQualityImprovement = crossoverChildren.Average(x => x.Quality - x.Parents.First().Quality);
-        var avgNonRootParentQualityImprovement = crossoverChildren.Average(x => x.Quality - x.Parents.Last().Quality);
-        var avgChildParentQuality = crossoverChildren.Average(x => x.Quality - x.Parents.Average(p => p.Quality));
-        var bestRootParentQualityImprovement = crossoverChildren.Max(x => x.Quality - x.Parents.First().Quality);
-        var bestNonRootParentQualityImprovement = crossoverChildren.Max(x => x.Quality - x.Parents.Last().Quality);
-        table.Rows["Average crossover improvement (root parent)"].Values.Add(avgRootParentQualityImprovement);
-        table.Rows["Average crossover improvement (non-root parent)"].Values.Add(avgNonRootParentQualityImprovement);
-        table.Rows["Best crossover improvement (root parent)"].Values.Add(bestRootParentQualityImprovement);
-        table.Rows["Best crossover improvement (non-root parent)"].Values.Add(bestNonRootParentQualityImprovement);
-        table.Rows["Average child-parents quality difference"].Values.Add(avgChildParentQuality);
-        table.Rows["Above average children"].Values.Add(aac / populationSize);
-        table.Rows["Above average children from above average parents"].Values.Add(aacp / populationSize);
-        #endregion
-
-        #region mutation improvement
-        if (!Results.ContainsKey("Mutation improvement")) {
-          table = new DataTable("Mutation improvement");
-          Results.Add(new Result("Mutation improvement", table));
-          table.Rows.AddRange(
-            new[]
-            {
-              new DataRow("Average mutation improvement") {VisualProperties = {StartIndexZero = true}},
-              new DataRow("Best mutation improvement") {VisualProperties = {StartIndexZero = true}},
-              new DataRow("Above average children") {VisualProperties = {StartIndexZero = true}},
-              new DataRow("Above average children from above average parents") {VisualProperties = {StartIndexZero = true}},
-            });
-        } else {
-          table = (DataTable)Results["Mutation improvement"].Value;
-        }
-
-        aac = 0;
-        aacp = 0;
-        var mutationChildren = vertices.Where(x => x.InDegree == 1).ToList();
-
-        foreach (var c in mutationChildren) {
-          if (c.Quality > averageQuality)
-            aac++;
+      foreach (var c in crossoverChildren) {
+        if (c.Quality > averageQuality) {
+          aac++;
           if (c.Parents.All(x => x.Quality > averageQuality))
             aacp++;
         }
-        var avgMutationImprovement = mutationChildren.Average(x => x.Quality - x.Parents.First().Quality);
-        var bestMutationImprovement = mutationChildren.Max(x => x.Quality - x.Parents.First().Quality);
+      }
+      var avgRootParentQualityImprovement = crossoverChildren.Average(x => x.Quality - x.Parents.First().Quality);
+      var avgNonRootParentQualityImprovement = crossoverChildren.Average(x => x.Quality - x.Parents.Last().Quality);
+      var avgChildParentQuality = crossoverChildren.Average(x => x.Quality - x.Parents.Average(p => p.Quality));
+      var bestRootParentQualityImprovement = crossoverChildren.Max(x => x.Quality - x.Parents.First().Quality);
+      var bestNonRootParentQualityImprovement = crossoverChildren.Max(x => x.Quality - x.Parents.Last().Quality);
+      table.Rows["Average crossover improvement (root parent)"].Values.Add(avgRootParentQualityImprovement);
+      table.Rows["Average crossover improvement (non-root parent)"].Values.Add(avgNonRootParentQualityImprovement);
+      table.Rows["Best crossover improvement (root parent)"].Values.Add(bestRootParentQualityImprovement);
+      table.Rows["Best crossover improvement (non-root parent)"].Values.Add(bestNonRootParentQualityImprovement);
+      table.Rows["Average child-parents quality difference"].Values.Add(avgChildParentQuality);
+      table.Rows["Above average children"].Values.Add(aac / populationSize);
+      table.Rows["Above average children from above average parents"].Values.Add(aacp / populationSize);
+      #endregion
 
-        table.Rows["Average mutation improvement"].Values.Add(avgMutationImprovement);
-        table.Rows["Best mutation improvement"].Values.Add(bestMutationImprovement);
-        table.Rows["Above average children"].Values.Add(aac / populationSize);
-        table.Rows["Above average children from above average parents"].Values.Add(aacp / populationSize);
-        #endregion
+      #region mutation improvement
+      if (!Results.ContainsKey("Mutation improvement")) {
+        table = new DataTable("Mutation improvement");
+        Results.Add(new Result("Mutation improvement", table));
+        table.Rows.AddRange(new[]
+          {
+              new DataRow("Average mutation improvement") { VisualProperties = { StartIndexZero = true } },
+              new DataRow("Best mutation improvement") { VisualProperties = { StartIndexZero = true } },
+              new DataRow("Above average children") { VisualProperties = { StartIndexZero = true } },
+              new DataRow("Above average children from above average parents") { VisualProperties = { StartIndexZero = true } },
+            });
+      } else {
+        table = (DataTable)Results["Mutation improvement"].Value;
       }
+
+      aac = 0;
+      aacp = 0;
+      var mutationChildren = vertices.Where(x => x.InDegree == 1).ToList();
+
+      foreach (var c in mutationChildren) {
+        if (c.Quality > averageQuality) {
+          aac++;
+          if (c.Parents.All(x => x.Quality > averageQuality))
+            aacp++;
+        }
+      }
+      var avgMutationImprovement = mutationChildren.Average(x => x.Quality - x.Parents.First().Quality);
+      var bestMutationImprovement = mutationChildren.Max(x => x.Quality - x.Parents.First().Quality);
+
+      table.Rows["Average mutation improvement"].Values.Add(avgMutationImprovement);
+      table.Rows["Best mutation improvement"].Values.Add(bestMutationImprovement);
+      table.Rows["Above average children"].Values.Add(aac / populationSize);
+      table.Rows["Above average children from above average parents"].Values.Add(aacp / populationSize);
+      #endregion
       return base.Apply();
     }
