Index: branches/HeuristicLab.EvolutionTracking/Build.cmd
===================================================================
--- branches/HeuristicLab.EvolutionTracking/Build.cmd	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/Build.cmd	(revision 10265)
@@ -0,0 +1,94 @@
+@ECHO OFF
+
+SET CLEANBEFOREBUILD=0
+
+SET SELECTED=
+SET CONFIGURATION=
+SET PLATFORM=
+
+IF "%~1"=="" GOTO :prompt_solution
+
+SET SELECTED=%1
+IF NOT EXIST %SELECTED% (
+  ECHO Solution file %SELECTED% could not be found.
+  GOTO :end
+)
+ECHO Building solution %SELECTED% ...
+GOTO :config_selection
+
+:prompt_solution
+SET /A COUNT=0
+FOR /F "tokens=*" %%A IN ('dir /B *.sln') DO (
+  CALL :forloopbody "%%A"
+)
+
+IF "%COUNT%"=="1" (
+  SET SELECTED=%SOLUTIONS.1%
+  ECHO Building %SOLUTIONS.1% as it is the only solution that was found ...
+  GOTO :config_selection
+)
+
+ECHO Found the following solutions:
+FOR /F "tokens=2* delims=.=" %%A IN ('SET SOLUTIONS.') DO ECHO %%A = %%B
+ECHO.
+SET /P SOLUTIONINDEX=Which solution to build? Type the number: 
+
+SET SELECTED=""
+FOR /F "tokens=2* delims=.=" %%A IN ('SET SOLUTIONS.') DO (
+  IF "%%A"=="%SOLUTIONINDEX%" SET SELECTED=%%B
+)
+
+IF %SELECTED%=="" GOTO :eof
+
+:config_selection
+IF "%~2"==""  GOTO :prompt_config
+
+SET CONFIGURATION=%~2
+ECHO Building configuration %CONFIGURATION% ...
+GOTO :platform_selection
+
+:prompt_config
+SET /P CONFIGURATION=Which configuration to build [Release]: 
+IF "%CONFIGURATION%"=="" SET CONFIGURATION=Release
+
+:platform_selection
+IF "%~3"=="" GOTO :prompt_platform
+  
+SET PLATFORM=%~3
+ECHO Building platform %PLATFORM% ...
+GOTO :main
+
+:prompt_platform
+SET /P PLATFORM=Which platform to build [Any CPU]: 
+IF "%PLATFORM%"=="" SET PLATFORM=Any CPU
+
+:main
+REM First find the path to the msbuild.exe by performing a registry query
+FOR /F "tokens=1,3 delims=	 " %%A IN ('REG QUERY "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0"') DO (
+  IF "%%A"=="MSBuildToolsPath" SET MSBUILDPATH=%%B)
+
+REM Then execute msbuild to clean and build the solution
+REM Disable that msbuild creates a cache file of the solution
+SET MSBuildUseNoSolutionCache=1
+REM Run msbuild to clean and then build
+IF "%CLEANBEFOREBUILD%"=="1" (
+  ECHO Cleaning ...
+  %MSBUILDPATH%msbuild.exe %SELECTED% /target:Clean /p:Configuration="%CONFIGURATION%",Platform="%PLATFORM%" /m:2 /nologo /verbosity:q /clp:ErrorsOnly
+)
+ECHO Building ...
+%MSBUILDPATH%msbuild.exe %SELECTED% /target:Rebuild /p:Configuration="%CONFIGURATION%",Platform="%PLATFORM%" /m:2 /nologo /verbosity:q /clp:ErrorsOnly
+
+ECHO.
+ECHO DONE.
+
+:end
+
+PAUSE
+
+GOTO :eof
+
+REM This workaround is necessary so that COUNT gets reevaluated
+:forloopbody
+SET /A COUNT+=1
+SET SOLUTIONS.%COUNT%=%1
+GOTO :eof
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/AncestryLayoutAdapter.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/AncestryLayoutAdapter.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/AncestryLayoutAdapter.cs	(revision 10265)
@@ -0,0 +1,38 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.EvolutionaryTracking.Views.Primitives;
+using HeuristicLab.Visualization;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  class AncestryLayoutAdapter : ILayoutAdapter<PrimitiveGroup> {
+    public IEnumerable<ILayoutNode<IGroup>> Convert(IGroup root, Func<PrimitiveGroup, ILayoutNode<PrimitiveGroup>> convertFunc) {
+      throw new NotImplementedException();
+    }
+
+    public IEnumerable<ILayoutNode<PrimitiveGroup>> Convert(PrimitiveGroup root, Func<PrimitiveGroup, ILayoutNode<PrimitiveGroup>> convertFunc) {
+      throw new NotImplementedException();
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/ExtendedSymbolicExpressionTreeCanvas.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/ExtendedSymbolicExpressionTreeCanvas.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/ExtendedSymbolicExpressionTreeCanvas.cs	(revision 10265)
@@ -0,0 +1,340 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.EvolutionaryTracking.Views.Primitives;
+using HeuristicLab.Visualization;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  public class ExtendedSymbolicExpressionTreeCanvas : ChartControl {
+    private const int HSize = 20;
+    private const int VSize = 15;
+    private const int HDistance = 5;
+    private const int VDistance = 5;
+    private const int MinGroupHorizontalSpacing = 200;
+    private const int MinGroupVerticalSpacing = 200;
+    private const int HorizontalGroupDistance = 20;
+    private const int VerticalGroupDistance = 20;
+
+    public ReingoldTilfordLayoutEngine<ISymbolicExpressionTreeNode> TreeLayoutEngine { get; set; }
+    public ReingoldTilfordLayoutEngine<ISymbolicExpressionTree> GroupsLayoutEngine { get; set; }
+
+    private SymbolicExpressionTreeLayoutAdapter layoutAdapter;
+
+    private Dictionary<ISymbolicExpressionTreeNode, IPrimitive> nodesToPrimitives;
+    private Dictionary<ISymbolicExpressionTree, IPrimitive> treesToGroups;
+
+    private Dictionary<Tuple<IPrimitive, IPrimitive>, Line> primitiveConnections;
+    private Dictionary<Tuple<IPrimitive, IPrimitive>, Line> groupsConnections;
+
+    private ISymbolicExpressionTreeNode currentSelected;
+    private ISymbolicExpressionTreeNode SelectedSubtree {
+      get { return currentSelected; }
+      set {
+        if (Chart == null)
+          Chart = new Chart(0, 0, PreferredSize.Width, PreferredSize.Height);
+
+        if (value == currentSelected) return;
+        var previousSelected = currentSelected;
+        currentSelected = value;
+
+        DisableUpdate();
+        if (previousSelected != null) HighlightSubtree(previousSelected, Color.Black); // un-highlight the previously selected subtree
+        if (currentSelected != null) HighlightSubtree(currentSelected, Color.DeepSkyBlue); // highlight the new selected subtree
+        EnableUpdate();
+        EnforceUpdate();
+      }
+    }
+
+    public ISymbolicExpressionTreeGenealogyGraph GenealogyGraph { get; set; }
+
+    private void ClearDictionaries() {
+      if (nodesToPrimitives == null) nodesToPrimitives = new Dictionary<ISymbolicExpressionTreeNode, IPrimitive>();
+      nodesToPrimitives.Clear();
+
+      if (treesToGroups == null) treesToGroups = new Dictionary<ISymbolicExpressionTree, IPrimitive>();
+      treesToGroups.Clear();
+
+      if (groupsConnections == null) groupsConnections = new Dictionary<Tuple<IPrimitive, IPrimitive>, Line>();
+      groupsConnections.Clear();
+
+      if (primitiveConnections == null) primitiveConnections = new Dictionary<Tuple<IPrimitive, IPrimitive>, Line>();
+      primitiveConnections.Clear();
+    }
+
+    private ISymbolicExpressionTree root;
+    public ISymbolicExpressionTree Root {
+      get {
+        return root;
+      }
+      set {
+        if (value == null)
+          throw new ArgumentNullException();
+
+        if (root == value) return;
+
+        ClearDictionaries();
+        TreeLayoutEngine.Reset();
+        GroupsLayoutEngine.Reset();
+
+        root = value;
+        currentSelected = null;
+
+        if (Chart == null)
+          Chart = new Chart(0, 0, PreferredSize.Width, PreferredSize.Height);
+
+        DisableUpdate();
+        Chart.Group.Clear();
+        var group = LayoutTree(root);
+        group.Ancestor = group;
+        group.Content = root;
+        Chart.Group.Add(group);
+        GroupsLayoutEngine.Root = group;
+        GroupsLayoutEngine.AddNode(group.Content, group);
+        treesToGroups.Add(group.Content, group);
+
+        // highlight the received fragment
+        var graphNode = GenealogyGraph.GetGraphNodes(root).First();
+        if (graphNode.InEdges != null) {
+          var arc = graphNode.InEdges.Last(x => x.Source != x.Target);
+          var fragment = (IFragment)arc.Data;
+          if (fragment != null && fragment.Root != null) {
+            HighlightSubtree(fragment.Root, Color.Orange);
+          }
+        }
+
+        EnableUpdate();
+        EnforceUpdate();
+      }
+    }
+
+    public ExtendedSymbolicExpressionTreeCanvas() {
+      TreeLayoutEngine = new ReingoldTilfordLayoutEngine<ISymbolicExpressionTreeNode> { MinHorizontalSpacing = HDistance + HSize, MinVerticalSpacing = VDistance + VSize };
+      layoutAdapter = new SymbolicExpressionTreeLayoutAdapter();
+      GroupsLayoutEngine = new ReingoldTilfordLayoutEngine<ISymbolicExpressionTree> { MinHorizontalSpacing = MinGroupHorizontalSpacing, MinVerticalSpacing = MinGroupVerticalSpacing };
+      if (Chart == null)
+        Chart = new Chart(0, 0, PreferredSize.Width, PreferredSize.Height);
+      nodesToPrimitives = new Dictionary<ISymbolicExpressionTreeNode, IPrimitive>();
+      treesToGroups = new Dictionary<ISymbolicExpressionTree, IPrimitive>();
+      groupsConnections = new Dictionary<Tuple<IPrimitive, IPrimitive>, Line>();
+      primitiveConnections = new Dictionary<Tuple<IPrimitive, IPrimitive>, Line>();
+    }
+
+    /// <summary>
+    /// Draws a symbolic expression tree using HeuristicLab.Visualization primitives and the ReingoldTilford layout algorithm.
+    /// </summary>
+    /// <param name="tree">The symbolic expression tree</param>
+    /// <returns>An IChart containing a group of primitives representing the tree.</returns>
+    private PrimitiveGroup LayoutTree(ISymbolicExpressionTree tree) {
+      var group = LayoutTree(tree.Root.GetSubtree(0).GetSubtree(0));
+      group.Content = tree;
+      return group;
+    }
+
+    // this function is used by the SymbolicExpressionTreeLayoutAdapter
+    private ILayoutNode<ISymbolicExpressionTreeNode> ConvertFunction(ISymbolicExpressionTreeNode node) {
+      ILayoutNode<ISymbolicExpressionTreeNode> layoutNode;
+      if (node.SubtreeCount == 0) {
+        layoutNode = new LabeledRectangle(Chart, 0, 0, HSize, VSize) { Text = node.ToString(), Font = new Font(FontFamily.GenericSansSerif, 12) };
+      } else {
+        layoutNode = new LabeledEllipse(Chart, 0, 0, HSize, VSize) { Text = node.ToString(), Font = new Font(FontFamily.GenericSansSerif, 12) };
+      }
+      // layoutNode.Children are not initialized here, but when the adapter expands the tree
+      layoutNode.Ancestor = layoutNode;
+      layoutNode.Content = node;
+      return layoutNode;
+    }
+
+    private PrimitiveGroup LayoutTree(ISymbolicExpressionTreeNode treeRoot) {
+      if (treeRoot == null) throw new ArgumentNullException();
+
+      var layoutNodes = layoutAdapter.Convert(treeRoot, ConvertFunction).ToList(); // returns a list of layoutNodes in breadth order (relative to the tree traversal)
+      TreeLayoutEngine.Reset();
+      var group = new PrimitiveGroup(Chart);
+      // add primitives (rectangles and ellipses corresponding to terminal/function nodes)
+      foreach (var layoutNode in layoutNodes) {
+        var brush = new SolidBrush(Color.Transparent);
+        var pen = new Pen(Color.Black);
+        var fontBrush = new SolidBrush(pen.Color);
+        var treeNode = layoutNode.Content;
+        layoutNode.Number = layoutNode.Parent == null ? 0 : layoutNode.Parent.Content.IndexOfSubtree(layoutNode.Content);
+        var primitive = (IPrimitive)layoutNode;
+        primitive.Brush = brush;
+        primitive.Pen = pen;
+        if (treeNode.SubtreeCount == 0) {
+          var rectangle = (LabeledRectangle)primitive;
+          rectangle.FontBrush = fontBrush;
+        } else {
+          var ellipse = (LabeledEllipse)primitive;
+          ellipse.FontBrush = fontBrush;
+        }
+        TreeLayoutEngine.AddNode(treeNode, layoutNode);
+        group.Add(primitive);
+        nodesToPrimitives.Add(treeNode, primitive);
+      }
+      TreeLayoutEngine.Root = (ILayoutNode<ISymbolicExpressionTreeNode>)nodesToPrimitives[treeRoot];
+      TreeLayoutEngine.CalculateLayout(); // calculate X,Y coordinates for each layout node
+
+      foreach (var layoutNode in layoutNodes) {
+        var primitive = (RectangularPrimitiveBase)layoutNode;
+        var lowerLeft = new PointD(layoutNode.X, layoutNode.Y);
+        primitive.SetPosition(lowerLeft, lowerLeft + new Offset(primitive.Size));
+      }
+      // connect nodes with lines
+      foreach (var layoutNode in layoutNodes) {
+        var primitive = (RectangularPrimitiveBase)layoutNode;
+        var pen = new Pen(Color.Black);
+        var node = layoutNode.Content;
+        if (node.SubtreeCount == 0) continue;
+        foreach (var subtree in node.Subtrees) {
+          var subtreePrimitive = (RectangularPrimitiveBase)nodesToPrimitives[subtree];
+          var start = new PointD(primitive.UpperRight.X - primitive.Size.Width / 2f, primitive.UpperRight.Y);
+          var end = new PointD(subtreePrimitive.LowerLeft.X + subtreePrimitive.Size.Width / 2f, subtreePrimitive.LowerLeft.Y);
+          var line = new Line(Chart, start, end, pen);
+          group.Add(line);
+          primitiveConnections.Add(new Tuple<IPrimitive, IPrimitive>(primitive, subtreePrimitive), line);
+        }
+      }
+      // once the coordonates for each primitive are updated according to the calculated layout, we update the bounds of the group (LowerLeft and UpperRight)
+      group.UpdateBounds();
+      return group;
+    }
+    /// <summary>
+    /// Handler for the user click event inside the ExtendedSymbolicExpressionTreeCanvas. When the user clicks, the following things should happen:
+    /// 1) The group of primitives containing the clicked screen point is identified
+    /// 2) The corresponding symbolic expression tree is retrieved from the groupsToTreesDictionary
+    /// 3) The corresponding genealogy graph node is retrieved from the GenealogyGraph
+    /// 4) The parents and the fragment are retrieved from the graph
+    /// 5) Both parents are laid out using the symbolic expression tree layout engine and the resulting groups of primitives are added to the canvas
+    /// 6) The fragment is highlighted in the root parent and in the other parent 
+    /// </summary>
+    /// <param name="sender"></param>
+    /// <param name="e"></param>
+    protected override void pictureBox_MouseUp(object sender, System.Windows.Forms.MouseEventArgs e) {
+      // STEP 1: Get the primitives and the group
+      var primitives = Chart.GetAllPrimitives(e.Location).Where(p => p is PrimitiveGroup).ToList();
+      if (primitives.Count == 0) return;
+      if (primitives.Count > 1) throw new Exception("Groups/trees should not overlap."); // in the extended canvas, the PrimitiveGroups (each representing a symbolic expression tree) should not overlap
+      var selectedGroup = (PrimitiveGroup)primitives[0];
+      var selectedPrimitive = selectedGroup.GetAllPrimitives(Chart.TransformPixelToWorld(e.Location)).First(p => p is ILayoutNode<ISymbolicExpressionTreeNode>); // similarly with the above condition, there should only be one primitive in that location
+      // STEP 2: Get the selected tree and the selected subtree
+      SelectedSubtree = ((ILayoutNode<ISymbolicExpressionTreeNode>)selectedPrimitive).Content;
+      var selectedTree = ((ILayoutNode<ISymbolicExpressionTree>)selectedGroup).Content;
+      // STEP 3: Get the genealogy graph node, the parents and the fragment
+      var graphNode = GenealogyGraph.GetGraphNodes(selectedTree).First(); // get the GenealogyGraphNode corresponding to the tree
+      var parentVertices = graphNode.InEdges.Select(edge => (SymbolicExpressionTreeGenealogyGraphNode)edge.Source).ToList();
+
+      DisableUpdate();
+
+      foreach (var edge in graphNode.InEdges) {
+        var parentVertex = (SymbolicExpressionTreeGenealogyGraphNode)edge.Source;
+        var parent = parentVertex.SymbolicExpressionTree;
+        if (treesToGroups.ContainsKey(parent)) continue;
+        var childGroup = LayoutTree(parent); // from the layout perspective, roles are reversed and genealogical parents become layout children
+        treesToGroups.Add(parent, childGroup);
+        Chart.Group.Add(childGroup);
+        if (selectedGroup.Children == null) selectedGroup.Children = new List<ILayoutNode<ISymbolicExpressionTree>>();
+        selectedGroup.Children.Add(childGroup);
+        childGroup.Parent = selectedGroup;
+        childGroup.Level = childGroup.Parent.Level + 1;
+        childGroup.Number = childGroup.Parent.Children.Count - 1;
+        childGroup.Ancestor = childGroup;
+        childGroup.Content = parent;
+        GroupsLayoutEngine.AddNode(childGroup.Content, childGroup);
+      }
+      var parents = parentVertices.Select(x => x.SymbolicExpressionTree).ToList();
+      // highlight the fragment
+      if (graphNode.InEdges.Count == 2) {
+        // highlight the fragment
+        var fragment = (IFragment)graphNode.InEdges.Last().Data;
+        if (!(fragment == null || fragment.Root == null)) {
+
+          var subtree0 = parents[0].IterateNodesPrefix().ElementAt(fragment.Index);
+          HighlightSubtree(subtree0, Color.Red);
+
+          var subtree1 = parents[1].IterateNodesPrefix().ElementAt(fragment.OldIndex);
+          HighlightSubtree(subtree1, Color.LimeGreen);
+        }
+      }
+      // layout the groups
+      var groups = Chart.Group.Primitives.Where(p => p is PrimitiveGroup).Cast<PrimitiveGroup>().ToList();
+      var maxSize = new SizeF(groups.Max(g => g.Size.Width), groups.Max(g => g.Size.Height));
+      GroupsLayoutEngine.MinHorizontalSpacing = maxSize.Width + HorizontalGroupDistance;
+      GroupsLayoutEngine.MinVerticalSpacing = maxSize.Height + VerticalGroupDistance;
+
+      GroupsLayoutEngine.CalculateLayout();
+      foreach (var group in Chart.Group.Primitives.Where(p => p is PrimitiveGroup).Cast<PrimitiveGroup>()) {
+        group.Move(new PointD(group.X, group.Y) - group.LowerLeft);
+      }
+      // draw or update (start,end) coordinates of group connections
+      foreach (var group in Chart.Group.Primitives.Where(p => p is PrimitiveGroup).Cast<PrimitiveGroup>()) {
+        if (group.Children == null) continue;
+        var start = new PointD(group.UpperRight.X - group.Size.Width / 2, group.UpperRight.Y);
+        foreach (var childGroup in group.Children.Cast<PrimitiveGroup>()) {
+          var tuple = new Tuple<IPrimitive, IPrimitive>(group, childGroup);
+          var childRoot = (RectangularPrimitiveBase)nodesToPrimitives[childGroup.Content.Root.GetSubtree(0).GetSubtree(0)];
+          var end = new PointD(childRoot.LowerLeft.X + childRoot.Size.Width / 2, childRoot.LowerLeft.Y);
+          if (groupsConnections.ContainsKey(tuple)) {
+            var line = groupsConnections[tuple];
+            line.SetPosition(start, end);
+          } else {
+            var line = new Line(Chart, start, end) { Pen = new Pen(Color.Black) };
+            Chart.Group.Add(line);
+            groupsConnections.Add(tuple, line);
+          }
+        }
+      }
+
+      EnableUpdate();
+      EnforceUpdate();
+
+      base.pictureBox_MouseUp(sender, e);
+    }
+    // highlight a given subtree with the specified color
+    public void HighlightSubtree(ISymbolicExpressionTreeNode subtree, Color color) {
+      foreach (var node in subtree.IterateNodesBreadth()) {
+        var primitive = nodesToPrimitives[node];
+        primitive.Pen.Brush = new SolidBrush(color);
+      }
+    }
+    // the (0,0) point of the HeuristicLab.Visualization.Chart is at the bottom left corner of the screen, while the (0,0) point of the layout engine 
+    // and of the actual user control is at the top left corner. so we have to vertically flip everything to maintain correct orientation.
+    private void FlipVertical() {
+      foreach (var primitive in Chart.Group.Primitives) {
+        var group = primitive as PrimitiveGroup;
+        if (group != null) {
+          foreach (var groupPrimitive in group.Primitives) {
+            var rp = groupPrimitive as RectangularPrimitiveBase;
+            if (rp != null) {
+              rp.SetPosition(rp.LowerLeft.X, Height - rp.UpperRight.Y, rp.UpperRight.X, Height - rp.LowerLeft.Y);
+            } else {
+              var lp = groupPrimitive as LinearPrimitiveBase;
+              if (lp != null) {
+                lp.SetPosition(lp.Start.X, Height - lp.Start.Y, lp.End.X, Height - lp.End.Y);
+              }
+            }
+          }
+        } else {
+          var lp = primitive as LinearPrimitiveBase;
+          if (lp != null) {
+            lp.SetPosition(lp.Start.X, Height - lp.Start.Y, lp.End.X, Height - lp.End.Y);
+          }
+        }
+      }
+    }
+    // some convenience methods for the lazy (enabling, disabling updates for the Chart)
+    private void EnableUpdate() {
+      Chart.UpdateEnabled = true;
+    }
+    private void DisableUpdate() {
+      Chart.UpdateEnabled = false;
+    }
+    private void EnforceUpdate() {
+      DisableUpdate();
+      FlipVertical();
+      EnableUpdate();
+      Chart.EnforceUpdate();
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/FrequentFragmentsDialog.Designer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/FrequentFragmentsDialog.Designer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/FrequentFragmentsDialog.Designer.cs	(revision 10265)
@@ -0,0 +1,53 @@
+﻿namespace HeuristicLab.EvolutionaryTracking.Views {
+  partial class FrequentFragmentsDialog {
+    /// <summary>
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary>
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Windows Form Designer generated code
+
+    /// <summary>
+    /// Required method for Designer support - do not modify
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.fragmentsPanel = new System.Windows.Forms.Panel();
+      this.SuspendLayout();
+      // 
+      // fragmentsPanel
+      // 
+      this.fragmentsPanel.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.fragmentsPanel.Location = new System.Drawing.Point(0, 0);
+      this.fragmentsPanel.Name = "fragmentsPanel";
+      this.fragmentsPanel.Size = new System.Drawing.Size(292, 270);
+      this.fragmentsPanel.TabIndex = 1;
+      // 
+      // FrequentFragmentsDialog
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.ClientSize = new System.Drawing.Size(292, 270);
+      this.Controls.Add(this.fragmentsPanel);
+      this.Name = "FrequentFragmentsDialog";
+      this.Text = "FrequentFragmentsDialog";
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    public System.Windows.Forms.Panel fragmentsPanel;
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/FrequentFragmentsDialog.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/FrequentFragmentsDialog.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/FrequentFragmentsDialog.cs	(revision 10265)
@@ -0,0 +1,10 @@
+﻿using System.Windows.Forms;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  public partial class FrequentFragmentsDialog : Form {
+    public FrequentFragmentsDialog() {
+      InitializeComponent();
+
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphChart.Designer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphChart.Designer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphChart.Designer.cs	(revision 10265)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  partial class GenealogyGraphChart {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      ((System.ComponentModel.ISupportInitialize)(this.pictureBox)).BeginInit();
+      this.SuspendLayout();
+      // 
+      // pictureBox
+      // 
+      this.pictureBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)));
+      this.pictureBox.Dock = System.Windows.Forms.DockStyle.Fill;
+      // 
+      // GenealogyGraphChart
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Name = "GenealogyGraphChart";
+      this.Controls.SetChildIndex(this.pictureBox, 0);
+      ((System.ComponentModel.ISupportInitialize)(this.pictureBox)).EndInit();
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphChart.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphChart.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphChart.cs	(revision 10265)
@@ -0,0 +1,396 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Linq;
+using System.Windows.Forms;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Visualization;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  public partial class GenealogyGraphChart : ChartControl {
+    private Dictionary<string, VisualGenealogyGraphNode> visualNodeMap; // map the uid of the genealogy graph vertex with a visual node (in this way each node is uniquely determined)
+    private Dictionary<Tuple<VisualGenealogyGraphNode, VisualGenealogyGraphNode>, VisualGenealogyGraphArc> visualArcMap;
+    private const int Diameter = 20; // node diameter
+    private int x, y; // coordinates for positioning each node
+    private const int Cx = 30, Cy = 30; // position increments
+    private VisualGenealogyGraphNode selectedGenealogyGraphNode;
+    public VisualGenealogyGraphNode SelectedGenealogyGraphNode { get { return selectedGenealogyGraphNode; } }
+    private Visualization.Rectangle targetRectangle; // provides a  rectangle mark of the currently selected genealogy graph node
+
+    public bool SimpleLineages { get; set; }
+    public bool LockGenealogy { get; set; }
+
+    private bool drawing;
+
+    private SymbolicExpressionTreeGenealogyGraph graph;
+    public SymbolicExpressionTreeGenealogyGraph Graph {
+      get { return graph; }
+      internal set {
+        graph = value;
+        if (graph == null) return;
+
+        visualNodeMap = new Dictionary<string, VisualGenealogyGraphNode>();
+        visualArcMap = new Dictionary<Tuple<VisualGenealogyGraphNode, VisualGenealogyGraphNode>, VisualGenealogyGraphArc>();
+
+        Chart.Group.Clear();
+        DrawGraph();
+      }
+    }
+
+    private VisualGenealogyGraphNode GetVisualGenealogyGraphNode(IVertex node) {
+      VisualGenealogyGraphNode visualNode;
+      visualNodeMap.TryGetValue(node.Id, out visualNode);
+      return visualNode;
+    }
+
+    private VisualGenealogyGraphArc GetVisualGenealogyGraphArc(IVertex source, IVertex target) {
+      VisualGenealogyGraphNode visualSource;
+      VisualGenealogyGraphNode visualTarget;
+      visualNodeMap.TryGetValue(source.Id, out visualSource);
+      visualNodeMap.TryGetValue(target.Id, out visualTarget);
+      if (visualSource != null && visualTarget != null) {
+        VisualGenealogyGraphArc visualArc;
+        visualArcMap.TryGetValue(
+          new Tuple<VisualGenealogyGraphNode, VisualGenealogyGraphNode>(visualSource, visualTarget), out visualArc);
+        if (visualArc != null) return visualArc;
+      }
+      return null;
+    }
+
+    public event MouseEventHandler GenealogyGraphNodeClicked;
+    private void OnGenealogyGraphNodeClicked(object sender, MouseEventArgs e) {
+      var clicked = GenealogyGraphNodeClicked;
+      if (clicked != null) clicked(sender, e);
+    }
+
+    public GenealogyGraphChart() {
+      //      InitializeComponent();
+      Chart = new Chart(0, 0, PreferredSize.Width, PreferredSize.Height);
+      x = 0;
+      y = PreferredSize.Height + Cx + 2 * Diameter;
+      Chart.Mode = ChartMode.Select;
+    }
+
+    public void DrawGraph() {
+      if (graph == null) return;
+      Chart.UpdateEnabled = false;
+
+      drawing = true;
+
+      var layers = Graph.Nodes.GroupBy(n => n.Rank).OrderBy(g => g.Key).Select(g => new { Rank = g.Key, Nodes = g.ToList() }).ToList();
+
+      y = PreferredSize.Height + Cx + 2 * Diameter;
+
+      for (int i = 0; i != layers.Count; ++i) {
+        x = 0;
+        layers[i].Nodes.Sort((b, a) => Graph.Compare(a, b));
+        double rank = Math.Floor(layers[i].Rank);
+        if (layers[i].Rank.IsAlmost(rank)) {
+          var visualTextNode = new VisualGenealogyGraphTextLabel(Chart, x, y + 2, x + Diameter, y + Diameter) {
+            FontBrush = new SolidBrush(Color.Black),
+            Font = new Font("Arial", Diameter - 4, FontStyle.Regular, GraphicsUnit.Pixel),
+            Text = String.Format("{0:0}", rank)
+          };
+          Chart.Group.Add(visualTextNode);
+        }
+
+        // sort descending by quality (using comparison defined in GenealogyGraphNode class)
+        x += (int)Math.Floor(1.5 * Cx); // reset horizontal coordinate
+
+        foreach (var node in layers[i].Nodes) {
+          var pen = new Pen(Color.LightGray);
+          var nl = Environment.NewLine;
+          var visualNode = new VisualGenealogyGraphNode(Chart, x, y, x + Diameter, y + Diameter, pen, null) {
+            Data = node,
+            ToolTipText = "Rank: " + node.Rank + nl +
+                          "Quality: " + String.Format("{0:0.0000}", node.Quality) + nl +
+                          "IsElite: " + node.IsElite
+          };
+          Chart.Group.Add(visualNode);
+          visualNodeMap.Add(node.Id, visualNode);
+
+          x += Cx; // increment horizontal coordinate
+        }
+
+        y -= Cy; // decrement vertical coordinate (because the origin is upside down)
+
+        // connect elites from successive layers with visual arcs
+        if (i == 0) continue;
+        var currLayer = layers[i].Nodes;
+        var prevLayer = layers[i - 1].Nodes;
+        foreach (var n in currLayer) {
+          foreach (var m in prevLayer) {
+            if (n.SymbolicExpressionTree != m.SymbolicExpressionTree) continue;
+            var v1 = GetVisualGenealogyGraphNode(n);
+            var v2 = GetVisualGenealogyGraphNode(m);
+
+            var pen = new Pen(Color.LightGray);
+            visualArcMap[Tuple.Create(v2, v1)] = AddArc(Chart, v2, v1, pen);
+          }
+        }
+      }
+      // add arcs separately (to avoid some ordering problems)
+      foreach (SymbolicExpressionTreeGenealogyGraphNode node in Graph.Nodes) {
+        VisualGenealogyGraphNode visualNode = GetVisualGenealogyGraphNode(node);
+        if (node.InEdges == null) continue;
+
+        foreach (Arc arc in node.InEdges) {
+          var visualParent = GetVisualGenealogyGraphNode(arc.Source);
+          var pen = new Pen(Color.Transparent);
+          visualArcMap[Tuple.Create(visualParent, visualNode)] = AddArc(Chart, visualParent, visualNode, pen);
+        }
+      }
+
+      // highlight the most recent common ancestor ("eve" individual)
+      //      var eve = graph.MostRecentCommonAncestor();
+      //      if (eve != null) {
+      //        var visualGraphNode = GetVisualGenealogyGraphNode(eve);
+
+      //        var brush = new SolidBrush(Color.BlueViolet);
+      //        visualGraphNode.FontBrush = brush;
+      //      }
+
+      Chart.UpdateEnabled = true;
+      Chart.EnforceUpdate();
+
+      drawing = false;
+    }
+
+    // add an arc between the source and the target nodes, using the specified pen color
+    // adds the arc to the arc lists of both nodes and to the primitive group of the chart
+    private static VisualGenealogyGraphArc AddArc(IChart chart, VisualGenealogyGraphNode source, VisualGenealogyGraphNode target, Pen pen, Brush brush = null) {
+      var arc = new VisualGenealogyGraphArc(chart, source, target, pen) { Brush = brush };
+      arc.UpdatePosition();
+      source.OutgoingArcs.Add(arc);
+      target.IncomingArcs.Add(arc);
+      chart.Group.Add(arc);
+      return arc;
+    }
+
+    protected override void pictureBox_MouseMove(object sender, MouseEventArgs e) {
+      if (!drawing) {
+        switch (e.Button) {
+          case MouseButtons.Left:
+            Chart.Mode = ChartMode.Select;
+            Cursor = Cursors.Default;
+            break;
+          case MouseButtons.Middle:
+            Chart.Mode = ChartMode.Move;
+            Cursor = Cursors.Hand;
+            break;
+        }
+        base.pictureBox_MouseMove(sender, e);
+      }
+    }
+
+    protected override void pictureBox_MouseUp(object sender, MouseEventArgs e) {
+      Cursor = Cursors.Default;
+      if (Chart.Mode == ChartMode.Move) {
+        Chart.Mode = ChartMode.Select;
+        return;
+      }
+
+      if (Chart.Mode != ChartMode.Select) {
+        base.pictureBox_MouseUp(sender, e);
+        return;
+      }
+
+      var visualNodes = Chart.GetAllPrimitives(e.Location).Where(p => p is VisualGenealogyGraphNode).ToList();
+      if (visualNodes.Count <= 0) {
+        selectedGenealogyGraphNode = null;
+        return;
+      }
+      if (selectedGenealogyGraphNode == visualNodes[0]) return;
+      selectedGenealogyGraphNode = visualNodes[0] as VisualGenealogyGraphNode;
+      if (selectedGenealogyGraphNode == null) return;
+
+      if (!LockGenealogy) {
+        // new node has been selected, clean up
+        Chart.UpdateEnabled = false;
+        if (ModifierKeys != Keys.Shift)
+          // clear colors
+          ClearAllNodes();
+        // use a rectangle to highlight the currently selected genealogy graph node
+        var gNode = selectedGenealogyGraphNode.Data;
+        var visualNode = GetVisualGenealogyGraphNode(gNode);
+
+        DrawLineage(visualNode, n => SimpleLineages ? n.IncomingArcs.Take(1) : n.IncomingArcs, a => a.Source);
+        visualNode.Brush = null;
+        DrawLineage(visualNode, n => n.OutgoingArcs, a => a.Target);
+      }
+
+      MarkSelectedNode();
+
+      // update
+      Chart.UpdateEnabled = true;
+      Chart.EnforceUpdate();
+
+      if (selectedGenealogyGraphNode != null)
+        /* emit clicked event */
+        OnGenealogyGraphNodeClicked(selectedGenealogyGraphNode, e);
+    }
+
+    private void DrawLineage(VisualGenealogyGraphNode node, Func<VisualGenealogyGraphNode, IEnumerable<VisualGenealogyGraphArc>> arcSelector, Func<VisualGenealogyGraphArc, VisualGenealogyGraphNode> nodeSelector) {
+      if (node.Brush != null) return;
+      node.Brush = new SolidBrush(node.Data.GetColor());
+      var arcs = arcSelector(node);
+      if (arcs == null) return;
+
+      foreach (var arc in arcs) {
+        var source = arc.Source.Data;
+        var target = arc.Target.Data;
+        var start = new Point((int)arc.Start.X, (int)arc.Start.Y);
+        var end = new Point((int)arc.End.X, (int)arc.End.Y);
+        arc.Pen.Brush = new LinearGradientBrush(start, end, source.GetColor(), target.GetColor());
+        arc.Pen.Color = Color.Transparent;
+        //        arc.Pen.FontBrush = new SolidBrush(Color.DarkGray);
+        DrawLineage(nodeSelector(arc), arcSelector, nodeSelector);
+      }
+    }
+
+    void MarkSelectedNode() {
+      var center = selectedGenealogyGraphNode.Center;
+      var size = selectedGenealogyGraphNode.Size;
+      double x1 = center.X - size.Width / 2;
+      double x2 = x1 + size.Width;
+      double y1 = center.Y - size.Height / 2;
+      double y2 = y1 + size.Height;
+      if (targetRectangle == null) {
+        targetRectangle = new Visualization.Rectangle(Chart, x1, y1, x2, y2, new Pen(Color.Black), null);
+        Chart.Group.Add(targetRectangle);
+      } else {
+        targetRectangle.SetPosition(x1, y1, x2, y2);
+      }
+    }
+
+    public void ClearAllNodes() {
+      foreach (var primitive in Chart.Group.Primitives) {
+        if (primitive is VisualGenealogyGraphArc) {
+          var arc = primitive as VisualGenealogyGraphArc;
+          var sourceData = arc.Source.Data.SymbolicExpressionTree;
+          var targetData = arc.Target.Data.SymbolicExpressionTree;
+          primitive.Pen.Brush = sourceData != targetData ? new SolidBrush(Color.Transparent) : new SolidBrush(Color.LightGray);
+        } else {
+          primitive.Brush = null;
+        }
+      }
+    }
+
+    public void HighlightNodes(IEnumerable<SymbolicExpressionTreeGenealogyGraphNode> nodes) {
+      Chart.UpdateEnabled = false;
+      ClearAllNodes();
+      foreach (var node in nodes) {
+        GetVisualGenealogyGraphNode(node).Brush = new SolidBrush(node.GetColor());
+      }
+      Chart.UpdateEnabled = true;
+      Chart.EnforceUpdate();
+    }
+
+    // TODO: optimize and reduce complexity of this method
+    public void HighlightNodes(IEnumerable<ISymbolicExpressionTree> trees) {
+      foreach (var tree in trees) {
+        var graphNodes = graph.GetGraphNodes(tree);
+        foreach (var graphNode in graphNodes) {
+          GetVisualGenealogyGraphNode(graphNode).Brush = new SolidBrush(graphNode.GetColor());
+        }
+      }
+    }
+
+    public void HighlightArcs(IEnumerable<IEdge> arcs, Color color) {
+      foreach (var a in arcs) {
+        var arc = GetVisualGenealogyGraphArc(a.Source, a.Target);
+        if (arc != null) {
+          var source = arc.Source.Data;
+          var target = arc.Target.Data;
+          var start = new Point((int)arc.Start.X, (int)arc.Start.Y);
+          var end = new Point((int)arc.End.X, (int)arc.End.Y);
+          arc.Pen.Brush = new LinearGradientBrush(start, end, source.GetColor(), target.GetColor());
+        }
+      }
+    }
+
+    public void HighlightNode(SymbolicExpressionTreeGenealogyGraphNode graphNode, Color color) {
+      GetVisualGenealogyGraphNode(graphNode).Brush = new SolidBrush(color);
+    }
+
+    public void HighlightAll() {
+      Chart.UpdateEnabled = false;
+      foreach (var visualNode in visualNodeMap.Values) {
+        visualNode.Brush = new SolidBrush(visualNode.Data.GetColor());
+      }
+      foreach (var arc in visualArcMap.Values) {
+        var source = arc.Source.Data;
+        var target = arc.Target.Data;
+        var start = new Point((int)arc.Start.X, (int)arc.Start.Y);
+        var end = new Point((int)arc.End.X, (int)arc.End.Y);
+        arc.Pen.Brush = new LinearGradientBrush(start, end, source.GetColor(), target.GetColor());
+      }
+      Chart.UpdateEnabled = true;
+      Chart.EnforceUpdate();
+    }
+
+    public void HighlightInDegree() {
+      Chart.UpdateEnabled = false;
+      ClearAllNodes();
+      double max = Graph.Nodes.Max(x => x.InEdges == null ? 0 : x.InEdges.Count);
+      foreach (var graphNode in Graph.Nodes) {
+        var visualNode = GetVisualGenealogyGraphNode(graphNode);
+        double deg = graphNode.InEdges == null ? 0 : graphNode.InEdges.Count;
+        int index = (int)(deg / max * ColorGradient.Colors.Count);
+        if (index == ColorGradient.Colors.Count) --index;
+        var color = ColorGradient.Colors[index];
+        visualNode.Brush = new SolidBrush(color);
+      }
+      Chart.UpdateEnabled = true;
+      Chart.EnforceUpdate();
+    }
+
+    public void HighlightOutDegree() {
+      Chart.UpdateEnabled = false;
+      ClearAllNodes();
+      var graphNodes = Graph.Nodes;
+      double max = graphNodes.Max(x => x.OutEdges == null ? 0 : x.OutEdges.Count);
+      foreach (var graphNode in graphNodes) {
+        var visualNode = GetVisualGenealogyGraphNode(graphNode);
+        double deg = graphNode.OutEdges == null ? 0 : graphNode.OutEdges.Count;
+        int index = (int)(deg / max * ColorGradient.Colors.Count);
+        if (index == ColorGradient.Colors.Count) --index;
+        var color = ColorGradient.Colors[index];
+        visualNode.Brush = new SolidBrush(color);
+      }
+      Chart.UpdateEnabled = true;
+      Chart.EnforceUpdate();
+    }
+  }
+
+  internal static class Util {
+    public static Color GetColor(this SymbolicExpressionTreeGenealogyGraphNode node) {
+      var colorIndex = (int)(node.Quality * ColorGradient.Colors.Count);
+      if (colorIndex >= ColorGradient.Colors.Count) --colorIndex;
+      return ColorGradient.Colors[colorIndex];
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphDialog.Designer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphDialog.Designer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphDialog.Designer.cs	(revision 10265)
@@ -0,0 +1,56 @@
+﻿namespace HeuristicLab.EvolutionaryTracking.Views {
+  partial class GenealogyGraphDialog {
+    /// <summary>
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary>
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Windows Form Designer generated code
+
+    /// <summary>
+    /// Required method for Designer support - do not modify
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.genealogyGraphChart1 = new HeuristicLab.EvolutionaryTracking.Views.GenealogyGraphChart();
+      this.SuspendLayout();
+      // 
+      // genealogyGraphChart1
+      // 
+      this.genealogyGraphChart1.BackColor = System.Drawing.SystemColors.Control;
+      this.genealogyGraphChart1.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.genealogyGraphChart1.Location = new System.Drawing.Point(0, 0);
+      this.genealogyGraphChart1.Name = "genealogyGraphChart1";
+      this.genealogyGraphChart1.ScaleOnResize = true;
+      this.genealogyGraphChart1.Size = new System.Drawing.Size(284, 262);
+      this.genealogyGraphChart1.TabIndex = 0;
+      // 
+      // GenealogyGraphDialog
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.ClientSize = new System.Drawing.Size(284, 262);
+      this.Controls.Add(this.genealogyGraphChart1);
+      this.Cursor = System.Windows.Forms.Cursors.Default;
+      this.Name = "GenealogyGraphDialog";
+      this.Text = "Genealogy";
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private GenealogyGraphChart genealogyGraphChart1;
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphDialog.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphDialog.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphDialog.cs	(revision 10265)
@@ -0,0 +1,13 @@
+﻿using System.Windows.Forms;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  public partial class GenealogyGraphDialog : Form {
+    public SymbolicExpressionTreeGenealogyGraph Graph {
+      set { genealogyGraphChart1.Graph = value; }
+    }
+
+    public GenealogyGraphDialog() {
+      InitializeComponent();
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphView.Designer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphView.Designer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphView.Designer.cs	(revision 10265)
@@ -0,0 +1,245 @@
+﻿
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  partial class GenealogyGraphView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.components = new System.ComponentModel.Container();
+      this.splitContainer = new System.Windows.Forms.SplitContainer();
+      this.symbolicExpressionTreeChart = new HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views.SymbolicExpressionTreeChart();
+      this.topControlBox = new System.Windows.Forms.Panel();
+      this.graphControlsGroupBox = new System.Windows.Forms.GroupBox();
+      this.lockGenealogyCheckBox = new System.Windows.Forms.CheckBox();
+      this.highlightAllButton = new System.Windows.Forms.Button();
+      this.simpleLineagesCheckBox = new System.Windows.Forms.CheckBox();
+      this.groupBox1 = new System.Windows.Forms.GroupBox();
+      this.matchConstantsCheckBox = new System.Windows.Forms.CheckBox();
+      this.matchVariableWeightsCheckBox = new System.Windows.Forms.CheckBox();
+      this.matchVariableNamesCheckBox = new System.Windows.Forms.CheckBox();
+      this.toolTip = new System.Windows.Forms.ToolTip(this.components);
+      this.genealogyGraphChart = new HeuristicLab.EvolutionaryTracking.Views.GenealogyGraphChart();
+      ((System.ComponentModel.ISupportInitialize)(this.splitContainer)).BeginInit();
+      this.splitContainer.Panel1.SuspendLayout();
+      this.splitContainer.Panel2.SuspendLayout();
+      this.splitContainer.SuspendLayout();
+      this.topControlBox.SuspendLayout();
+      this.graphControlsGroupBox.SuspendLayout();
+      this.groupBox1.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // splitContainer
+      // 
+      this.splitContainer.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.splitContainer.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
+      this.splitContainer.Location = new System.Drawing.Point(3, 53);
+      this.splitContainer.Name = "splitContainer";
+      // 
+      // splitContainer.Panel1
+      // 
+      this.splitContainer.Panel1.Controls.Add(this.genealogyGraphChart);
+      this.splitContainer.Panel1MinSize = 50;
+      // 
+      // splitContainer.Panel2
+      // 
+      this.splitContainer.Panel2.Controls.Add(this.symbolicExpressionTreeChart);
+      this.splitContainer.Panel2MinSize = 50;
+      this.splitContainer.Size = new System.Drawing.Size(1066, 722);
+      this.splitContainer.SplitterDistance = 488;
+      this.splitContainer.TabIndex = 7;
+      // 
+      // symbolicExpressionTreeChart
+      // 
+      this.symbolicExpressionTreeChart.BackgroundColor = System.Drawing.Color.White;
+      this.symbolicExpressionTreeChart.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.symbolicExpressionTreeChart.LineColor = System.Drawing.Color.Black;
+      this.symbolicExpressionTreeChart.Location = new System.Drawing.Point(0, 0);
+      this.symbolicExpressionTreeChart.Name = "symbolicExpressionTreeChart";
+      this.symbolicExpressionTreeChart.Size = new System.Drawing.Size(572, 720);
+      this.symbolicExpressionTreeChart.Spacing = 5;
+      this.symbolicExpressionTreeChart.SuspendRepaint = false;
+      this.symbolicExpressionTreeChart.TabIndex = 2;
+      this.symbolicExpressionTreeChart.TextFont = new System.Drawing.Font("Times New Roman", 8F);
+      this.symbolicExpressionTreeChart.Tree = null;
+      // 
+      // topControlBox
+      // 
+      this.topControlBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.topControlBox.Controls.Add(this.graphControlsGroupBox);
+      this.topControlBox.Location = new System.Drawing.Point(3, 3);
+      this.topControlBox.Name = "topControlBox";
+      this.topControlBox.Size = new System.Drawing.Size(1066, 44);
+      this.topControlBox.TabIndex = 6;
+      // 
+      // graphControlsGroupBox
+      // 
+      this.graphControlsGroupBox.Controls.Add(this.lockGenealogyCheckBox);
+      this.graphControlsGroupBox.Controls.Add(this.highlightAllButton);
+      this.graphControlsGroupBox.Controls.Add(this.simpleLineagesCheckBox);
+      this.graphControlsGroupBox.Location = new System.Drawing.Point(1, -2);
+      this.graphControlsGroupBox.Name = "graphControlsGroupBox";
+      this.graphControlsGroupBox.Size = new System.Drawing.Size(98, 44);
+      this.graphControlsGroupBox.TabIndex = 11;
+      this.graphControlsGroupBox.TabStop = false;
+      this.graphControlsGroupBox.Text = "Graph controls";
+      // 
+      // lockGenealogyCheckBox
+      // 
+      this.lockGenealogyCheckBox.Appearance = System.Windows.Forms.Appearance.Button;
+      this.lockGenealogyCheckBox.Location = new System.Drawing.Point(66, 14);
+      this.lockGenealogyCheckBox.Name = "lockGenealogyCheckBox";
+      this.lockGenealogyCheckBox.Size = new System.Drawing.Size(24, 24);
+      this.lockGenealogyCheckBox.TabIndex = 17;
+      this.toolTip.SetToolTip(this.lockGenealogyCheckBox, "Lock genealogy");
+      this.lockGenealogyCheckBox.UseVisualStyleBackColor = true;
+      this.lockGenealogyCheckBox.CheckedChanged += new System.EventHandler(this.lockGenealogyCheckBox_CheckedChanged);
+      // 
+      // highlightAllButton
+      // 
+      this.highlightAllButton.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink;
+      this.highlightAllButton.Location = new System.Drawing.Point(6, 14);
+      this.highlightAllButton.Name = "highlightAllButton";
+      this.highlightAllButton.Size = new System.Drawing.Size(24, 24);
+      this.highlightAllButton.TabIndex = 13;
+      this.toolTip.SetToolTip(this.highlightAllButton, "Fitness gradient");
+      this.highlightAllButton.UseVisualStyleBackColor = true;
+      this.highlightAllButton.Click += new System.EventHandler(this.highlightAllButton_Click);
+      // 
+      // simpleLineagesCheckBox
+      // 
+      this.simpleLineagesCheckBox.Appearance = System.Windows.Forms.Appearance.Button;
+      this.simpleLineagesCheckBox.Location = new System.Drawing.Point(36, 14);
+      this.simpleLineagesCheckBox.Name = "simpleLineagesCheckBox";
+      this.simpleLineagesCheckBox.Size = new System.Drawing.Size(24, 24);
+      this.simpleLineagesCheckBox.TabIndex = 12;
+      this.toolTip.SetToolTip(this.simpleLineagesCheckBox, "Simple lineages");
+      this.simpleLineagesCheckBox.UseVisualStyleBackColor = true;
+      this.simpleLineagesCheckBox.CheckedChanged += new System.EventHandler(this.simpleLineagesCheckBox_CheckedChanged);
+      // 
+      // groupBox1
+      // 
+      this.groupBox1.Controls.Add(this.matchConstantsCheckBox);
+      this.groupBox1.Controls.Add(this.matchVariableWeightsCheckBox);
+      this.groupBox1.Controls.Add(this.matchVariableNamesCheckBox);
+      this.groupBox1.Location = new System.Drawing.Point(104, 1);
+      this.groupBox1.Name = "groupBox1";
+      this.groupBox1.Size = new System.Drawing.Size(325, 44);
+      this.groupBox1.TabIndex = 12;
+      this.groupBox1.TabStop = false;
+      this.groupBox1.Text = "Matching constraints";
+      // 
+      // matchConstantsCheckBox
+      // 
+      this.matchConstantsCheckBox.AutoSize = true;
+      this.matchConstantsCheckBox.Checked = true;
+      this.matchConstantsCheckBox.CheckState = System.Windows.Forms.CheckState.Checked;
+      this.matchConstantsCheckBox.Location = new System.Drawing.Point(6, 19);
+      this.matchConstantsCheckBox.Name = "matchConstantsCheckBox";
+      this.matchConstantsCheckBox.Size = new System.Drawing.Size(102, 17);
+      this.matchConstantsCheckBox.TabIndex = 5;
+      this.matchConstantsCheckBox.Text = "Constant values";
+      this.matchConstantsCheckBox.UseVisualStyleBackColor = true;
+      this.matchConstantsCheckBox.CheckedChanged += new System.EventHandler(this.matchConstantsCheckBox_CheckedChanged);
+      // 
+      // matchVariableWeightsCheckBox
+      // 
+      this.matchVariableWeightsCheckBox.AutoSize = true;
+      this.matchVariableWeightsCheckBox.Checked = true;
+      this.matchVariableWeightsCheckBox.CheckState = System.Windows.Forms.CheckState.Checked;
+      this.matchVariableWeightsCheckBox.Location = new System.Drawing.Point(114, 19);
+      this.matchVariableWeightsCheckBox.Name = "matchVariableWeightsCheckBox";
+      this.matchVariableWeightsCheckBox.Size = new System.Drawing.Size(103, 17);
+      this.matchVariableWeightsCheckBox.TabIndex = 6;
+      this.matchVariableWeightsCheckBox.Text = "Variable weights";
+      this.matchVariableWeightsCheckBox.UseVisualStyleBackColor = true;
+      this.matchVariableWeightsCheckBox.CheckedChanged += new System.EventHandler(this.matchVariableWeightsCheckBox_CheckedChanged);
+      // 
+      // matchVariableNamesCheckBox
+      // 
+      this.matchVariableNamesCheckBox.AutoSize = true;
+      this.matchVariableNamesCheckBox.Checked = true;
+      this.matchVariableNamesCheckBox.CheckState = System.Windows.Forms.CheckState.Checked;
+      this.matchVariableNamesCheckBox.Location = new System.Drawing.Point(223, 19);
+      this.matchVariableNamesCheckBox.Name = "matchVariableNamesCheckBox";
+      this.matchVariableNamesCheckBox.Size = new System.Drawing.Size(98, 17);
+      this.matchVariableNamesCheckBox.TabIndex = 7;
+      this.matchVariableNamesCheckBox.Text = "Variable names";
+      this.matchVariableNamesCheckBox.UseVisualStyleBackColor = true;
+      this.matchVariableNamesCheckBox.CheckedChanged += new System.EventHandler(this.matchVariableNamesCheckBox_CheckedChanged);
+      // 
+      // genealogyGraphChart
+      // 
+      this.genealogyGraphChart.BackColor = System.Drawing.SystemColors.Control;
+      this.genealogyGraphChart.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.genealogyGraphChart.Location = new System.Drawing.Point(0, 0);
+      this.genealogyGraphChart.LockGenealogy = false;
+      this.genealogyGraphChart.Name = "genealogyGraphChart";
+      this.genealogyGraphChart.ScaleOnResize = true;
+      this.genealogyGraphChart.SimpleLineages = false;
+      this.genealogyGraphChart.Size = new System.Drawing.Size(486, 720);
+      this.genealogyGraphChart.TabIndex = 2;
+      // 
+      // GenealogyGraphView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.groupBox1);
+      this.Controls.Add(this.splitContainer);
+      this.Controls.Add(this.topControlBox);
+      this.Name = "GenealogyGraphView";
+      this.Size = new System.Drawing.Size(1072, 778);
+      this.splitContainer.Panel1.ResumeLayout(false);
+      this.splitContainer.Panel2.ResumeLayout(false);
+      ((System.ComponentModel.ISupportInitialize)(this.splitContainer)).EndInit();
+      this.splitContainer.ResumeLayout(false);
+      this.topControlBox.ResumeLayout(false);
+      this.graphControlsGroupBox.ResumeLayout(false);
+      this.groupBox1.ResumeLayout(false);
+      this.groupBox1.PerformLayout();
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.SplitContainer splitContainer;
+    private SymbolicExpressionTreeChart symbolicExpressionTreeChart;
+
+    private GenealogyGraphChart genealogyGraphChart;
+    private System.Windows.Forms.ToolTip toolTip;
+    private System.Windows.Forms.Panel topControlBox;
+    private System.Windows.Forms.GroupBox groupBox1;
+    private System.Windows.Forms.CheckBox matchConstantsCheckBox;
+    private System.Windows.Forms.CheckBox matchVariableWeightsCheckBox;
+    private System.Windows.Forms.CheckBox matchVariableNamesCheckBox;
+    private System.Windows.Forms.GroupBox graphControlsGroupBox;
+    private System.Windows.Forms.Button highlightAllButton;
+    private System.Windows.Forms.CheckBox simpleLineagesCheckBox;
+    private System.Windows.Forms.CheckBox lockGenealogyCheckBox;
+
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphView.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphView.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphView.cs	(revision 10265)
@@ -0,0 +1,242 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Windows.Forms;
+using HeuristicLab.Core.Views;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
+using HeuristicLab.MainForm;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  [View("SymbolicExpressionTreeGenealogyGraph")]
+  [Content(typeof(SymbolicExpressionTreeGenealogyGraph), IsDefaultView = true)]
+  public sealed partial class GenealogyGraphView : ItemView {
+    private VisualSymbolicExpressionTreeNode selectedVisualSymbExprTreeNode;
+    private SymbolicExpressionTreeNodeSimilarityComparer comparer;
+    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> clonedNodes;
+
+    public new SymbolicExpressionTreeGenealogyGraph Content {
+      get { return (SymbolicExpressionTreeGenealogyGraph)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public GenealogyGraphView()
+      : base() {
+      InitializeComponent();
+      // set button icons here because if set in the designer file, they get overwritten
+      this.highlightAllButton.Image = Common.Resources.VSImageLibrary.Gradient;
+      this.simpleLineagesCheckBox.Image = Common.Resources.VSImageLibrary.ArrowDown;
+      this.lockGenealogyCheckBox.Image = Common.Resources.VSImageLibrary.ProtectForm;
+
+      comparer = new SymbolicExpressionTreeNodeSimilarityComparer {
+        MatchConstantValues = true,
+        MatchVariableWeights = true,
+        MatchVariableNames = true
+      };
+    }
+
+    protected override void DeregisterContentEvents() {
+      // TODO: Deregister your event handlers here
+      genealogyGraphChart.GenealogyGraphNodeClicked -= graphChart_GenealogyGraphNodeClicked;
+      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeClicked -= treeChart_SymbolicExpressionTreeNodeClicked;
+      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeDoubleClicked -= treeChart_SymbolicExpressionTreeNodeDoubleClicked;
+      Content.GraphUpdated -= genealogyGraphUpdated;
+      base.DeregisterContentEvents();
+    }
+
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      // TODO: Register your event handlers here
+      genealogyGraphChart.GenealogyGraphNodeClicked += graphChart_GenealogyGraphNodeClicked;
+      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeClicked += treeChart_SymbolicExpressionTreeNodeClicked;
+      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeDoubleClicked += treeChart_SymbolicExpressionTreeNodeDoubleClicked;
+      Content.GraphUpdated += genealogyGraphUpdated;
+    }
+
+    #region Event Handlers (Content)
+    // TODO: Put event handlers of the content here
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null)
+        genealogyGraphChart.Graph = null;
+      else {
+        genealogyGraphChart.Graph = Content;
+        //        var best = Content.Nodes.OrderByDescending(x => x.Quality).First();
+        //        symbolicExpressionTreeChart.Tree = best.SymbolicExpressionTree;
+      }
+    }
+
+    private void Content_GraphChanged(object sender, EventArgs e) {
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      genealogyGraphChart.Enabled = Content != null;
+    }
+    #endregion
+
+    #region Event Handlers (child controls)
+
+    // TODO: Put event handlers of child controls here.
+    private void graphChart_GenealogyGraphNodeClicked(object sender, MouseEventArgs e) {
+      // the type hierarchy goes like this: VisualGenealogyGraphNode --> GenealogyGraphNode --> SymbolicExpressionTree
+      var visualGenealogyGraphNode = (VisualGenealogyGraphNode)sender;
+      var genealogyGraphNode = visualGenealogyGraphNode.Data;
+      symbolicExpressionTreeChart.Tree = genealogyGraphNode.SymbolicExpressionTree;
+
+      if (genealogyGraphNode.InEdges == null) return;
+      var arc = genealogyGraphNode.InEdges.Last(x => x.Source != x.Target);
+      if (arc == null || arc.Data == null) return;
+      var fragment = (IFragment)arc.Data;
+      if (fragment.Root == null) return;
+      foreach (var node in fragment.Root.IterateNodesBreadth()) {
+        var visualSymbExprTreeNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
+        visualSymbExprTreeNode.LineColor = Color.OrangeRed;
+      }
+      symbolicExpressionTreeChart.Repaint();
+    }
+
+    private void genealogyGraphUpdated(object sender, EventArgs args) {
+      genealogyGraphChart.Graph = Content;
+    }
+
+    private void treeChart_SymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
+      genealogyGraphChart.Chart.UpdateEnabled = false;
+      switch (e.Button) {
+        case MouseButtons.Left: {
+            selectedVisualSymbExprTreeNode = (VisualSymbolicExpressionTreeNode)sender;
+            if (selectedVisualSymbExprTreeNode == null) return;
+            ISymbolicExpressionTreeNode selectedSubtree = selectedVisualSymbExprTreeNode.SymbolicExpressionTreeNode;
+            var clonedSubtree = (ISymbolicExpressionTreeNode)selectedSubtree.Clone();
+            // map original nodes to cloned nodes
+            clonedNodes = selectedSubtree.IterateNodesPrefix()
+                                         .Zip(clonedSubtree.IterateNodesPrefix(), (original, clone) => new { original, clone })
+                                         .ToDictionary(p => p.original, p => p.clone);
+
+            foreach (var node in symbolicExpressionTreeChart.Tree.IterateNodesPrefix()) {
+              symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node).FillColor = Color.Transparent;
+            }
+            foreach (var node in selectedSubtree.IterateNodesPrefix()) {
+              symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node).FillColor = Color.LightBlue;
+            }
+            break;
+          }
+        case MouseButtons.Middle: {
+            var visualNode = (VisualSymbolicExpressionTreeNode)sender;
+            if (selectedVisualSymbExprTreeNode == null || selectedVisualSymbExprTreeNode == visualNode) return;
+            var selectedNode = visualNode.SymbolicExpressionTreeNode;
+            if (clonedNodes.ContainsKey(selectedNode)) {
+              var selectedClone = clonedNodes[selectedNode];
+              var parent = selectedClone.Parent;
+              if (parent == null) break;
+              int index = parent.IndexOfSubtree(selectedClone);
+              if (index == -1) break;
+              parent.RemoveSubtree(parent.IndexOfSubtree(selectedClone));
+              foreach (var node in selectedNode.IterateNodesPrefix()) {
+                symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node).FillColor = Color.Transparent;
+              }
+            }
+            break;
+          }
+      }
+      if (selectedVisualSymbExprTreeNode == null || clonedNodes == null) return;
+      // update visual graph nodes that contain matching trees
+      MatchNodesAndRepaint();
+      // refresh the tree chart
+      symbolicExpressionTreeChart.Repaint();
+    }
+
+    void MatchNodesAndRepaint() {
+      genealogyGraphChart.Chart.UpdateEnabled = false;
+      genealogyGraphChart.ClearAllNodes(); // clear node colors
+      var fragment = new Fragment { Root = clonedNodes[selectedVisualSymbExprTreeNode.SymbolicExpressionTreeNode] };
+      var fragmentLength = fragment.Length;
+      // highlight nodes
+      genealogyGraphChart.HighlightNodes(from node in genealogyGraphChart.Graph.Nodes
+                                         let tree = node.SymbolicExpressionTree
+                                         where tree.Length >= fragmentLength
+                                         where tree.Root.ContainsFragment(fragment, comparer)
+                                         select tree);
+      // highlight edges that contain a matching fragment
+      var fragmentSimilarityComparer = new SymbolicExpressionTreeFragmentSimilarityComparer {
+        SimilarityComparer = comparer
+      };
+      var matchingEdges = genealogyGraphChart.Graph.Nodes.Where(n => n.InEdges != null)
+                           .SelectMany(n => n.InEdges).Where(edge => edge.Data != null && ((IFragment)edge.Data).Root != null)
+                           .Where(edge => fragmentSimilarityComparer.Equals(fragment, (IFragment)edge.Data));
+      genealogyGraphChart.HighlightArcs(matchingEdges, Color.DodgerBlue);
+
+
+      genealogyGraphChart.Chart.UpdateEnabled = true;
+      genealogyGraphChart.Chart.EnforceUpdate();
+    }
+
+    private void treeChart_SymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
+    }
+    #endregion
+
+    private void matchConstantsCheckBox_CheckedChanged(object sender, EventArgs e) {
+      comparer.MatchConstantValues = matchConstantsCheckBox.Checked;
+      if (selectedVisualSymbExprTreeNode != null)
+        MatchNodesAndRepaint();
+    }
+
+    private void matchVariableWeightsCheckBox_CheckedChanged(object sender, EventArgs e) {
+      comparer.MatchVariableWeights = matchVariableWeightsCheckBox.Checked;
+      if (selectedVisualSymbExprTreeNode != null)
+        MatchNodesAndRepaint();
+    }
+
+    private void matchVariableNamesCheckBox_CheckedChanged(object sender, EventArgs e) {
+      comparer.MatchVariableNames = matchVariableNamesCheckBox.Checked;
+      if (selectedVisualSymbExprTreeNode != null)
+        MatchNodesAndRepaint();
+    }
+
+    private void simpleLineagesCheckBox_CheckedChanged(object sender, EventArgs e) {
+      genealogyGraphChart.SimpleLineages = simpleLineagesCheckBox.Checked;
+    }
+
+    private void highlightAllButton_Click(object sender, EventArgs e) {
+      symbolicExpressionTreeChart.Repaint();
+      genealogyGraphChart.HighlightAll();
+    }
+
+    private void lockGenealogyCheckBox_CheckedChanged(object sender, EventArgs e) {
+      genealogyGraphChart.LockGenealogy = lockGenealogyCheckBox.Checked;
+    }
+
+    private void highlightRootParentsButton_Click(object sender, EventArgs e) {
+      var nodes = genealogyGraphChart.Graph.Nodes.Where(n => n.InEdges != null && n.InEdges.Count == 2).Select(n => (SymbolicExpressionTreeGenealogyGraphNode)n.InEdges[0].Source).ToList();
+      genealogyGraphChart.HighlightNodes(nodes);
+    }
+
+    private void highlightSecondaryParentsButton_Click(object sender, EventArgs e) {
+      var nodes = genealogyGraphChart.Graph.Nodes.Where(n => n.InEdges != null && n.InEdges.Count == 2).Select(n => (SymbolicExpressionTreeGenealogyGraphNode)n.InEdges[1].Source).ToList();
+      genealogyGraphChart.HighlightNodes(nodes);
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj	(revision 10265)
@@ -0,0 +1,183 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{318DFE8C-CA23-4F1B-A4AC-62B425060241}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.EvolutionaryTracking.Views</RootNamespace>
+    <AssemblyName>HeuristicLab.EvolutionaryTracking.Views-3.4</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.MainForm-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.MainForm.WindowsForms-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis-3.4.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Visualization-3.3, Version=3.3.0.5170, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Visualization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AncestryLayoutAdapter.cs" />
+    <Compile Include="ExtendedSymbolicExpressionTreeCanvas.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="FrequentFragmentsDialog.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="FrequentFragmentsDialog.Designer.cs">
+      <DependentUpon>FrequentFragmentsDialog.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GenealogyGraphChart.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="GenealogyGraphChart.Designer.cs">
+      <DependentUpon>GenealogyGraphChart.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GenealogyGraphDialog.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="GenealogyGraphDialog.designer.cs">
+      <DependentUpon>GenealogyGraphDialog.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GenealogyGraphView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="GenealogyGraphView.Designer.cs">
+      <DependentUpon>GenealogyGraphView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="LineageExplorerView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="LineageExplorerView.Designer.cs">
+      <DependentUpon>LineageExplorerView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Primitives\LabeledEllipse.cs" />
+    <Compile Include="Primitives\LabeledRectangle.cs" />
+    <Compile Include="Primitives\PrimitiveGroup.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="VisualGenealogyGraphArc.cs" />
+    <Compile Include="VisualGenealogyGraphNode.cs" />
+    <Compile Include="VisualGenealogyGraphTextLabel.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.EvolutionaryTracking\3.4\HeuristicLab.EvolutionTracking-3.4.csproj">
+      <Project>{1f75cea3-464f-4a6f-b2f0-04b9841ebc16}</Project>
+      <Name>HeuristicLab.EvolutionTracking-3.4</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj.user
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj.user	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj.user	(revision 10265)
@@ -0,0 +1,6 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectView>ShowAllFiles</ProjectView>
+  </PropertyGroup>
+</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/LineageExplorerView.Designer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/LineageExplorerView.Designer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/LineageExplorerView.Designer.cs	(revision 10265)
@@ -0,0 +1,301 @@
+﻿namespace HeuristicLab.EvolutionaryTracking.Views {
+  partial class LineageExplorerView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.components = new System.ComponentModel.Container();
+      this.karyographTab = new System.Windows.Forms.TabControl();
+      this.tabPage1 = new System.Windows.Forms.TabPage();
+      this.panel1 = new System.Windows.Forms.Panel();
+      this.qualityImprovementTreeView = new System.Windows.Forms.TreeView();
+      this.symbolicExpressionTreeChart = new HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views.SymbolicExpressionTreeChart();
+      this.scopeListTreeView = new System.Windows.Forms.TreeView();
+      this.panel2 = new System.Windows.Forms.Panel();
+      this.button1 = new System.Windows.Forms.Button();
+      this.showGenealogyButton = new System.Windows.Forms.Button();
+      this.calculateFragmentFrequencyButton = new System.Windows.Forms.Button();
+      this.tabPage2 = new System.Windows.Forms.TabPage();
+      this.panel4 = new System.Windows.Forms.Panel();
+      this.panel3 = new System.Windows.Forms.Panel();
+      this.showFrequentFragmentsButton = new System.Windows.Forms.Button();
+      this.textBox2 = new System.Windows.Forms.TextBox();
+      this.thresholdLabel = new System.Windows.Forms.Label();
+      this.bestNTextBox = new System.Windows.Forms.TextBox();
+      this.consideredTrees = new System.Windows.Forms.Label();
+      this.tabPage3 = new System.Windows.Forms.TabPage();
+      this.karyographTab.SuspendLayout();
+      this.tabPage1.SuspendLayout();
+      this.panel1.SuspendLayout();
+      this.panel2.SuspendLayout();
+      this.tabPage2.SuspendLayout();
+      this.panel3.SuspendLayout();
+      this.tabPage3.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // karyographTab
+      // 
+      this.karyographTab.Controls.Add(this.tabPage1);
+      this.karyographTab.Controls.Add(this.tabPage2);
+      this.karyographTab.Controls.Add(this.tabPage3);
+      this.karyographTab.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.karyographTab.Location = new System.Drawing.Point(0, 0);
+      this.karyographTab.Name = "karyographTab";
+      this.karyographTab.SelectedIndex = 0;
+      this.karyographTab.Size = new System.Drawing.Size(1016, 669);
+      this.karyographTab.TabIndex = 2;
+      // 
+      // tabPage1
+      // 
+      this.tabPage1.Controls.Add(this.panel1);
+      this.tabPage1.Controls.Add(this.panel2);
+      this.tabPage1.Location = new System.Drawing.Point(4, 22);
+      this.tabPage1.Name = "tabPage1";
+      this.tabPage1.Padding = new System.Windows.Forms.Padding(3);
+      this.tabPage1.Size = new System.Drawing.Size(1008, 643);
+      this.tabPage1.TabIndex = 0;
+      this.tabPage1.Text = "Lineages";
+      this.tabPage1.UseVisualStyleBackColor = true;
+      // 
+      // panel1
+      // 
+      this.panel1.Controls.Add(this.qualityImprovementTreeView);
+      this.panel1.Controls.Add(this.symbolicExpressionTreeChart);
+      this.panel1.Controls.Add(this.scopeListTreeView);
+      this.panel1.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.panel1.Location = new System.Drawing.Point(3, 36);
+      this.panel1.Name = "panel1";
+      this.panel1.Size = new System.Drawing.Size(1002, 604);
+      this.panel1.TabIndex = 1;
+      // 
+      // qualityImprovementTreeView
+      // 
+      this.qualityImprovementTreeView.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.qualityImprovementTreeView.HideSelection = false;
+      this.qualityImprovementTreeView.Location = new System.Drawing.Point(887, 0);
+      this.qualityImprovementTreeView.Name = "qualityImprovementTreeView";
+      this.qualityImprovementTreeView.Size = new System.Drawing.Size(115, 604);
+      this.qualityImprovementTreeView.TabIndex = 10;
+      this.qualityImprovementTreeView.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.qualityImprovementTreeView_AfterSelect);
+      // 
+      // symbolicExpressionTreeChart
+      // 
+      this.symbolicExpressionTreeChart.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+            | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.symbolicExpressionTreeChart.BackgroundColor = System.Drawing.Color.White;
+      this.symbolicExpressionTreeChart.LineColor = System.Drawing.Color.Black;
+      this.symbolicExpressionTreeChart.Location = new System.Drawing.Point(155, 0);
+      this.symbolicExpressionTreeChart.Name = "symbolicExpressionTreeChart";
+      this.symbolicExpressionTreeChart.Size = new System.Drawing.Size(726, 604);
+      this.symbolicExpressionTreeChart.Spacing = 5;
+      this.symbolicExpressionTreeChart.SuspendRepaint = false;
+      this.symbolicExpressionTreeChart.TabIndex = 12;
+      this.symbolicExpressionTreeChart.TextFont = new System.Drawing.Font("Times New Roman", 8F);
+      this.symbolicExpressionTreeChart.Tree = null;
+      // 
+      // scopeListTreeView
+      // 
+      this.scopeListTreeView.Dock = System.Windows.Forms.DockStyle.Left;
+      this.scopeListTreeView.HideSelection = false;
+      this.scopeListTreeView.Location = new System.Drawing.Point(0, 0);
+      this.scopeListTreeView.Name = "scopeListTreeView";
+      this.scopeListTreeView.Size = new System.Drawing.Size(155, 604);
+      this.scopeListTreeView.TabIndex = 11;
+      this.scopeListTreeView.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.scopeListTreeView_AfterSelect);
+      // 
+      // panel2
+      // 
+      this.panel2.Controls.Add(this.button1);
+      this.panel2.Controls.Add(this.showGenealogyButton);
+      this.panel2.Controls.Add(this.calculateFragmentFrequencyButton);
+      this.panel2.Dock = System.Windows.Forms.DockStyle.Top;
+      this.panel2.Location = new System.Drawing.Point(3, 3);
+      this.panel2.Name = "panel2";
+      this.panel2.Size = new System.Drawing.Size(1002, 33);
+      this.panel2.TabIndex = 1;
+      // 
+      // button1
+      // 
+      this.button1.AutoSize = true;
+      this.button1.Location = new System.Drawing.Point(239, 4);
+      this.button1.Name = "button1";
+      this.button1.Size = new System.Drawing.Size(135, 23);
+      this.button1.TabIndex = 2;
+      this.button1.Text = "Show frequent fragments";
+      this.button1.UseVisualStyleBackColor = true;
+      this.button1.Click += new System.EventHandler(this.button1_Click);
+      // 
+      // showGenealogyButton
+      // 
+      this.showGenealogyButton.AutoSize = true;
+      this.showGenealogyButton.Location = new System.Drawing.Point(129, 4);
+      this.showGenealogyButton.Name = "showGenealogyButton";
+      this.showGenealogyButton.Size = new System.Drawing.Size(104, 23);
+      this.showGenealogyButton.TabIndex = 1;
+      this.showGenealogyButton.Text = "Show genealogy";
+      this.showGenealogyButton.UseVisualStyleBackColor = true;
+      this.showGenealogyButton.Click += new System.EventHandler(this.showGenealogyButton_Click);
+      // 
+      // calculateFragmentFrequencyButton
+      // 
+      this.calculateFragmentFrequencyButton.AutoSize = true;
+      this.calculateFragmentFrequencyButton.Location = new System.Drawing.Point(4, 4);
+      this.calculateFragmentFrequencyButton.Name = "calculateFragmentFrequencyButton";
+      this.calculateFragmentFrequencyButton.Size = new System.Drawing.Size(119, 23);
+      this.calculateFragmentFrequencyButton.TabIndex = 0;
+      this.calculateFragmentFrequencyButton.Text = "Fragment frequencies";
+      this.calculateFragmentFrequencyButton.UseVisualStyleBackColor = true;
+      this.calculateFragmentFrequencyButton.Click += new System.EventHandler(this.calculateFragmentFrequencyButton_Click);
+      // 
+      // tabPage2
+      // 
+      this.tabPage2.Controls.Add(this.panel4);
+      this.tabPage2.Controls.Add(this.panel3);
+      this.tabPage2.Location = new System.Drawing.Point(4, 22);
+      this.tabPage2.Name = "tabPage2";
+      this.tabPage2.Padding = new System.Windows.Forms.Padding(3);
+      this.tabPage2.Size = new System.Drawing.Size(1008, 643);
+      this.tabPage2.TabIndex = 1;
+      this.tabPage2.Text = "Fragments";
+      this.tabPage2.UseVisualStyleBackColor = true;
+      // 
+      // panel4
+      // 
+      this.panel4.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.panel4.Location = new System.Drawing.Point(3, 33);
+      this.panel4.Name = "panel4";
+      this.panel4.Size = new System.Drawing.Size(1002, 607);
+      this.panel4.TabIndex = 1;
+      // 
+      // panel3
+      // 
+      this.panel3.Controls.Add(this.showFrequentFragmentsButton);
+      this.panel3.Controls.Add(this.textBox2);
+      this.panel3.Controls.Add(this.thresholdLabel);
+      this.panel3.Controls.Add(this.bestNTextBox);
+      this.panel3.Controls.Add(this.consideredTrees);
+      this.panel3.Dock = System.Windows.Forms.DockStyle.Top;
+      this.panel3.Location = new System.Drawing.Point(3, 3);
+      this.panel3.Name = "panel3";
+      this.panel3.Size = new System.Drawing.Size(1002, 30);
+      this.panel3.TabIndex = 0;
+      // 
+      // showFrequentFragmentsButton
+      // 
+      this.showFrequentFragmentsButton.AutoSize = true;
+      this.showFrequentFragmentsButton.Location = new System.Drawing.Point(218, 3);
+      this.showFrequentFragmentsButton.Name = "showFrequentFragmentsButton";
+      this.showFrequentFragmentsButton.Size = new System.Drawing.Size(135, 23);
+      this.showFrequentFragmentsButton.TabIndex = 19;
+      this.showFrequentFragmentsButton.Text = "Show frequent fragments";
+      this.showFrequentFragmentsButton.UseVisualStyleBackColor = true;
+      this.showFrequentFragmentsButton.Click += new System.EventHandler(this.showFrequentFragmentsButton_Click);
+      // 
+      // textBox2
+      // 
+      this.textBox2.Location = new System.Drawing.Point(173, 5);
+      this.textBox2.Name = "textBox2";
+      this.textBox2.Size = new System.Drawing.Size(39, 20);
+      this.textBox2.TabIndex = 18;
+      this.textBox2.Text = "0.2";
+      // 
+      // thresholdLabel
+      // 
+      this.thresholdLabel.AutoSize = true;
+      this.thresholdLabel.Location = new System.Drawing.Point(113, 9);
+      this.thresholdLabel.Name = "thresholdLabel";
+      this.thresholdLabel.Size = new System.Drawing.Size(54, 13);
+      this.thresholdLabel.TabIndex = 17;
+      this.thresholdLabel.Text = "Threshold";
+      // 
+      // bestNTextBox
+      // 
+      this.bestNTextBox.Location = new System.Drawing.Point(68, 6);
+      this.bestNTextBox.Name = "bestNTextBox";
+      this.bestNTextBox.Size = new System.Drawing.Size(39, 20);
+      this.bestNTextBox.TabIndex = 16;
+      this.bestNTextBox.Text = "10";
+      // 
+      // consideredTrees
+      // 
+      this.consideredTrees.AutoSize = true;
+      this.consideredTrees.Location = new System.Drawing.Point(3, 9);
+      this.consideredTrees.Name = "consideredTrees";
+      this.consideredTrees.Size = new System.Drawing.Size(63, 13);
+      this.consideredTrees.TabIndex = 15;
+      this.consideredTrees.Text = "Best n trees";
+      // 
+      // tabPage3
+      // 
+      this.tabPage3.Location = new System.Drawing.Point(4, 22);
+      this.tabPage3.Name = "tabPage3";
+      this.tabPage3.Padding = new System.Windows.Forms.Padding(3);
+      this.tabPage3.Size = new System.Drawing.Size(1008, 643);
+      this.tabPage3.TabIndex = 2;
+      this.tabPage3.Text = "Karyograph";
+      this.tabPage3.UseVisualStyleBackColor = true;
+      // 
+      // LineageExplorerView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.karyographTab);
+      this.Name = "LineageExplorerView";
+      this.Size = new System.Drawing.Size(1016, 669);
+      this.karyographTab.ResumeLayout(false);
+      this.tabPage1.ResumeLayout(false);
+      this.panel1.ResumeLayout(false);
+      this.panel2.ResumeLayout(false);
+      this.panel2.PerformLayout();
+      this.tabPage2.ResumeLayout(false);
+      this.panel3.ResumeLayout(false);
+      this.panel3.PerformLayout();
+      this.tabPage3.ResumeLayout(false);
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.TabControl karyographTab;
+    private System.Windows.Forms.TabPage tabPage1;
+    private System.Windows.Forms.Panel panel1;
+    private System.Windows.Forms.TreeView qualityImprovementTreeView;
+    private Encodings.SymbolicExpressionTreeEncoding.Views.SymbolicExpressionTreeChart symbolicExpressionTreeChart;
+    private System.Windows.Forms.TreeView scopeListTreeView;
+    private System.Windows.Forms.TabPage tabPage2;
+    private System.Windows.Forms.Panel panel2;
+    private System.Windows.Forms.Button button1;
+    private System.Windows.Forms.Button showGenealogyButton;
+    private System.Windows.Forms.Button calculateFragmentFrequencyButton;
+    private System.Windows.Forms.Panel panel3;
+    private System.Windows.Forms.Button showFrequentFragmentsButton;
+    private System.Windows.Forms.TextBox textBox2;
+    private System.Windows.Forms.Label thresholdLabel;
+    private System.Windows.Forms.TextBox bestNTextBox;
+    private System.Windows.Forms.Label consideredTrees;
+    private System.Windows.Forms.Panel panel4;
+    private System.Windows.Forms.TabPage tabPage3;
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/LineageExplorerView.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/LineageExplorerView.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/LineageExplorerView.cs	(revision 10265)
@@ -0,0 +1,278 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Windows.Forms;
+using HeuristicLab.Common;
+using HeuristicLab.Core.Views;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
+using HeuristicLab.MainForm;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  [View("LineageExplorerView")]
+  [Content(typeof(LineageExplorer), IsDefaultView = false)]
+  public sealed partial class LineageExplorerView : ItemView {
+    private Dictionary<TreeNode, ISymbolicExpressionTree> treeMap;
+    private List<SymbolicExpressionTreeGenealogyGraphNode> lineage;
+
+    private Dictionary<ISymbolicExpressionTree, Dictionary<ISymbolicExpressionTreeNode, double>> fragmentFrequencies;
+
+    public new LineageExplorer Content {
+      get { return (LineageExplorer)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public LineageExplorerView() {
+      InitializeComponent();
+      treeMap = new Dictionary<TreeNode, ISymbolicExpressionTree>();
+    }
+
+    protected override void DeregisterContentEvents() {
+      // TODO: Deregister your event handlers here
+      base.DeregisterContentEvents();
+    }
+
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      // TODO: Register your event handlers here
+    }
+
+    #region Event Handlers (Content)
+    // TODO: Put event handlers of the content here
+    #endregion
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+      } else {
+        var tuples = Content.Trees.OrderByDescending(x => x.Item2).ToList();
+        scopeListTreeView.Nodes.AddRange(tuples.Select(x => new TreeNode(x.Item2.ToString())).ToArray());
+
+        for (int i = 0; i != tuples.Count; ++i) {
+          treeMap.Add(scopeListTreeView.Nodes[i], tuples[i].Item1);
+          double quality = tuples[i].Item2;
+          int colorIndex = (int)Math.Floor(quality * ColorGradient.Colors.Count);
+          var color = ColorGradient.Colors[colorIndex];
+          scopeListTreeView.Nodes[i].ForeColor = color;
+        }
+      }
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      // TODO: Enable or disable controls based on whether the content is null or the view is set readonly
+    }
+
+    private void scopeListTreeView_AfterSelect(object sender, TreeViewEventArgs e) {
+      var treeNode = scopeListTreeView.SelectedNode;
+      var symbExprTree = treeMap[treeNode];
+
+      fragmentFrequencies = fragmentFrequencies ?? new Dictionary<ISymbolicExpressionTree, Dictionary<ISymbolicExpressionTreeNode, double>>();
+
+      if (fragmentFrequencies.ContainsKey(symbExprTree) && false) {
+        // colorize tree nodes according to fragment frequencies
+        symbolicExpressionTreeChart.SuspendRepaint = true;
+        var frequencies = fragmentFrequencies[symbExprTree];
+
+        foreach (var node in symbExprTree.IterateNodesBreadth()) {
+          double freq = frequencies[node];
+          int index = (int)Math.Floor(freq * ColorGradient.Colors.Count / scopeListTreeView.GetNodeCount(false));
+          if (index == ColorGradient.Colors.Count) index--;
+          var color = ColorGradient.Colors[index];
+          var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
+          visualNode.FillColor = Color.FromArgb(200, color);
+        }
+        symbolicExpressionTreeChart.SuspendRepaint = false;
+        symbolicExpressionTreeChart.Repaint();
+      }
+      // highlight crossover fragment
+      HighlightFragment(symbExprTree);
+
+      var graphNode = Content.GenealogyGraph.GetGraphNodes(symbExprTree).Last();
+      lineage = lineage ?? new List<SymbolicExpressionTreeGenealogyGraphNode>();
+      lineage.Clear();
+      lineage.Add(graphNode);
+
+      var gn = graphNode;
+      while (gn.InEdges != null && gn.InEdges.Count != 0) {
+        gn = (SymbolicExpressionTreeGenealogyGraphNode)gn.InEdges[0].Source;
+        lineage.Add(gn);
+      }
+      lineage.Reverse(); // increasing order by generation
+
+      // update the righthand side tree view 
+      qualityImprovementTreeView.Nodes.Clear();
+      for (int i = 0; i != lineage.Count; ++i) {
+        var node = new TreeNode(string.Format("Generation {0}", lineage[i].Rank));
+        qualityImprovementTreeView.Nodes.Add(node);
+        var quality = lineage[i].Quality;
+        int colorIndex = (int)Math.Floor(quality * ColorGradient.Colors.Count);
+        var color = ColorGradient.Colors[colorIndex];
+        node.ForeColor = color;
+      }
+    }
+
+    /// <summary>
+    /// Given a symbolic expression tree, find the corresponding vertex in the genealogy graph, and highlight the fragment
+    /// that is saved as a data member in the incoming arc from the parent in the previous generation
+    /// </summary>
+    /// <param name="symbExprTree"></param>
+    private void HighlightFragment(ISymbolicExpressionTree symbExprTree) {
+      // update the symbolic expression tree chart with the new selected tree:
+      symbolicExpressionTreeChart.SuspendRepaint = true;
+      symbolicExpressionTreeChart.Tree = symbExprTree;
+      var matchingNodes = Content.GenealogyGraph.GetGraphNodes(symbExprTree);
+      SymbolicExpressionTreeGenealogyGraphNode graphNode = matchingNodes.First();
+      if (graphNode.InEdges == null) {
+        symbolicExpressionTreeChart.SuspendRepaint = false;
+        symbolicExpressionTreeChart.Repaint();
+        return;
+      }
+      var fragment = graphNode.InEdges.Count == 1 ? (IFragment)graphNode.InEdges[0].Data : (IFragment)graphNode.InEdges[1].Data;
+      if (fragment.Root == null) {
+        symbolicExpressionTreeChart.SuspendRepaint = false;
+        symbolicExpressionTreeChart.Repaint();
+        return;
+      }
+      foreach (var node in fragment.Root.IterateNodesBreadth()) {
+        var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
+        visualNode.LineColor = Color.DodgerBlue;
+      }
+      symbolicExpressionTreeChart.SuspendRepaint = false;
+      symbolicExpressionTreeChart.Repaint();
+    }
+
+    private void qualityImprovementTreeView_AfterSelect(object sender, TreeViewEventArgs e) {
+      var tree = lineage[qualityImprovementTreeView.SelectedNode.Index].SymbolicExpressionTree;
+      HighlightFragment(tree);
+    }
+
+    private void calculateFragmentFrequencyButton_Click(object sender, EventArgs e) {
+      // the individual can occur multiple times in the graph if it is(was) elite. we take the first occurence.
+      var graphNode = Content.GenealogyGraph.GetGraphNodes(symbolicExpressionTreeChart.Tree).First();
+      var trees = Content.GenealogyGraph.Nodes.Where(x => x.Rank.IsAlmost(graphNode.Rank)).Select(x => x.SymbolicExpressionTree).ToList();
+
+      var fragments = graphNode.SymbolicExpressionTree.IterateNodesBreadth().Select(n => new Fragment { Root = n });
+
+      var similarityComparer = new SymbolicExpressionTreeNodeSimilarityComparer {
+        MatchConstantValues = false,
+        MatchVariableNames = true,
+        MatchVariableWeights = false
+      };
+
+      var canonicalSorter = new SymbolicExpressionTreeCanonicalSorter();
+
+      fragmentFrequencies = fragmentFrequencies ?? new Dictionary<ISymbolicExpressionTree, Dictionary<ISymbolicExpressionTreeNode, double>>();
+
+      if (!fragmentFrequencies.ContainsKey(graphNode.SymbolicExpressionTree)) {
+        fragmentFrequencies[graphNode.SymbolicExpressionTree] = new Dictionary<ISymbolicExpressionTreeNode, double>();
+      }
+
+      fragmentFrequencies[graphNode.SymbolicExpressionTree].Clear();
+
+      symbolicExpressionTreeChart.SuspendRepaint = true;
+      foreach (var f in fragments) {
+        double freq = 0;
+
+        foreach (var t in trees) {
+          if (t.Root.ContainsFragment(f, similarityComparer)) ++freq;
+        }
+
+        fragmentFrequencies[graphNode.SymbolicExpressionTree].Add(f.Root, freq);
+
+        // colorize tree nodes according to fragment frequencies
+        int index = (int)Math.Floor(freq * ColorGradient.Colors.Count / trees.Count);
+        if (index == ColorGradient.Colors.Count) index--;
+        var color = ColorGradient.Colors[index];
+        foreach (var node in f.Root.IterateNodesBreadth()) {
+          var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
+          visualNode.FillColor = Color.FromArgb(200, color);
+        }
+      }
+
+      symbolicExpressionTreeChart.SuspendRepaint = false;
+      symbolicExpressionTreeChart.Repaint();
+    }
+
+    private void symbolicExpressionTreeChart_SymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
+    }
+
+    private void showGenealogyButton_Click(object sender, EventArgs e) {
+      var tree = symbolicExpressionTreeChart.Tree;
+      if (tree == null) return;
+      var graphNode = Content.GenealogyGraph.GetGraphNodes(tree).First();
+
+      var graph = new SymbolicExpressionTreeGenealogyGraph();
+      var ancestors = graphNode.Ancestors();
+      foreach (var ancestorNode in ancestors) {
+        graph.AddNode(ancestorNode);
+      }
+      using (var dialog = new GenealogyGraphDialog { Graph = graph }) {
+        dialog.ShowDialog(this);
+      }
+    }
+
+    private void button1_Click(object sender, EventArgs e) {
+      using (var dialog = new FrequentFragmentsDialog()) {
+        var panel = new Panel { Dock = DockStyle.Left, Anchor = AnchorStyles.Left | AnchorStyles.Top | AnchorStyles.Bottom };
+
+        panel.Controls.Add(new SymbolicExpressionTreeChart() { Tree = treeMap.Values.First() });
+        panel.Controls.Add(new Label { Text = "Fragment frequency." });
+
+        dialog.fragmentsPanel.Controls.Add(panel);
+
+        dialog.ShowDialog(this);
+      }
+    }
+
+    private void showFrequentFragmentsButton_Click(object sender, EventArgs e) {
+      int bestN;
+      bool success = int.TryParse(bestNTextBox.Text, out bestN);
+      if (!success) bestN = 10;
+      var tuples = Content.Trees.Select(t => new { Tree = t.Item1, Quality = t.Item2 }).OrderByDescending(x => x.Quality).ToList();
+      var bestTrees = tuples.Take(bestN).Select(x => x.Tree).ToList();
+
+      var similarityComparer = new SymbolicExpressionTreeNodeSimilarityComparer {
+        MatchConstantValues = false,
+        MatchVariableNames = true,
+        MatchVariableWeights = false
+      };
+
+      var fragments = bestTrees.SelectMany(t => t.IterateNodesBreadth()).Where(n => n.GetLength() >= 3).Distinct(similarityComparer).Select(n => new Fragment { Root = n });
+
+      double bestNQuality = tuples.Take(bestN).Sum(x => x.Quality); // average quality of best N individuals in the population
+
+      using (var dialog = new FrequentFragmentsDialog()) {
+        foreach (var fragment in fragments.Take(20)) {
+          double avgQuality = bestNQuality;
+          double frequency = bestN;
+          foreach (var t in tuples.Skip(bestN)) {
+            var tree = t.Tree;
+            if (tree.Root.ContainsFragment(fragment, similarityComparer)) {
+              avgQuality += t.Quality;
+              frequency++;
+            }
+          }
+          if (frequency > 0.2) {
+            var panel = new Panel {
+              Dock = DockStyle.Left,
+              Anchor = AnchorStyles.Left | AnchorStyles.Top | AnchorStyles.Bottom
+            };
+
+            panel.Controls.Add(new SymbolicExpressionTreeChart() { Tree = treeMap.Values.First() });
+            panel.Controls.Add(new Label { Text = "Fragment frequency." });
+
+            dialog.fragmentsPanel.Controls.Add(panel);
+          }
+        }
+        dialog.ShowDialog(this);
+      }
+    }
+
+    #region Event Handlers (child controls)
+    // TODO: Put event handlers of child controls here.
+    #endregion
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Plugin.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Plugin.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Plugin.cs	(revision 10265)
@@ -0,0 +1,41 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  [Plugin("HeuristicLab.EvolutionaryTracking.Views", "Provides controls and views for the evolution graph and related structures.", "3.4.2.7439")]
+  [PluginFile("HeuristicLab.EvolutionaryTracking.Views-3.4.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Core.Views", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "3.4")]
+  [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views", "3.4")]
+  [PluginDependency("HeuristicLab.MainForm", "3.3")]
+  [PluginDependency("HeuristicLab.MainForm.WindowsForms", "3.3")]
+  [PluginDependency("HeuristicLab.Visualization", "3.3")]
+  [PluginDependency("HeuristicLab.EvolutionaryTracking", "3.4")]
+  [PluginDependency("HeuristicLab.Problems.DataAnalysis.Symbolic", "3.4")]
+
+  public class HeuristicLabEvolutionaryTrackingPlugin : PluginBase {
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Primitives/LabeledEllipse.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Primitives/LabeledEllipse.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Primitives/LabeledEllipse.cs	(revision 10265)
@@ -0,0 +1,105 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using HeuristicLab.Visualization;
+
+namespace HeuristicLab.EvolutionaryTracking.Views.Primitives {
+  public class LabeledEllipse : Ellipse, ILayoutNode<ISymbolicExpressionTreeNode> {
+    private string text;
+    public string Text { get { return text; } set { text = value; } }
+
+    private Font font;
+    public Font Font { get { return font; } set { font = value; } }
+
+    private Brush fontBrush;
+    public Brush FontBrush { get { return fontBrush; } set { fontBrush = value; } }
+
+    public LabeledEllipse(IChart chart, PointD lowerLeft, PointD upperRight)
+      : base(chart, lowerLeft, upperRight) {
+      font = new Font(FontFamily.GenericSansSerif, 10);
+    }
+    public LabeledEllipse(IChart chart, double x1, double y1, double x2, double y2)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2)) {
+    }
+    public LabeledEllipse(IChart chart, PointD lowerLeft, PointD upperRight, Pen pen, Brush brush)
+      : base(chart, lowerLeft, upperRight, pen, brush) {
+      font = new Font(FontFamily.GenericSansSerif, 10);
+    }
+    public LabeledEllipse(IChart chart, double x1, double y1, double x2, double y2, Pen pen, Brush brush)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2), pen, brush) {
+    }
+
+    public override void Draw(Graphics graphics) {
+      var p = Chart.TransformWorldToPixel(new PointD(LowerLeft.X, LowerLeft.Y));
+      var s = Chart.TransformWorldToPixel(Size);
+      var stringSize = graphics.MeasureString(Text, Font);
+      var fontSize = Font.Size * s.Width / stringSize.Width;
+      if (fontSize > 12) fontSize = 12; // limit maximum font size to 10pt
+      font = new Font(font.Name, fontSize, FontStyle.Regular, GraphicsUnit.Pixel);
+      stringSize = graphics.MeasureString(Text, Font);
+      graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
+      graphics.DrawString(Text, Font, FontBrush, p.X + (s.Width - stringSize.Width) / 2f, p.Y - (s.Height + stringSize.Height) / 2f);
+      base.Draw(graphics);
+    }
+
+    public ILayoutNode<ISymbolicExpressionTreeNode> Thread { get; set; }
+    public ILayoutNode<ISymbolicExpressionTreeNode> Ancestor { get; set; }
+    public ILayoutNode<ISymbolicExpressionTreeNode> Parent { get; set; }
+    public List<ILayoutNode<ISymbolicExpressionTreeNode>> Children { get; set; }
+    public float Mod { get; set; }
+    public float Prelim { get; set; }
+    public float Change { get; set; }
+    public float Shift { get; set; }
+    public int Number { get; set; }
+    public int Level { get; set; }
+    public float X { get; set; }
+    public float Y { get; set; }
+    public bool IsLeaf {
+      get { return Children == null || Children.Count == 0; }
+    }
+    public ILayoutNode<ISymbolicExpressionTreeNode> NextLeft {
+      get {
+        return Children == null ? Thread : Children.First();
+      }
+    }
+    public ILayoutNode<ISymbolicExpressionTreeNode> NextRight {
+      get {
+        return Children == null ? Thread : Children.Last();
+      }
+    }
+    public ILayoutNode<ISymbolicExpressionTreeNode> LeftSibling {
+      get {
+        if (Parent == null) return null;
+        return Number == 0 ? null : Parent.Children[Number - 1];
+      }
+    }
+    public ILayoutNode<ISymbolicExpressionTreeNode> LeftmostSibling {
+      get {
+        if (Parent == null) return null;
+        return Number == 0 ? null : Parent.Children[0];
+      }
+    }
+    public ISymbolicExpressionTreeNode Content { get; set; }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Primitives/LabeledRectangle.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Primitives/LabeledRectangle.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Primitives/LabeledRectangle.cs	(revision 10265)
@@ -0,0 +1,106 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using HeuristicLab.Visualization;
+using Rectangle = HeuristicLab.Visualization.Rectangle;
+
+namespace HeuristicLab.EvolutionaryTracking.Views.Primitives {
+  public class LabeledRectangle : Rectangle, ILayoutNode<ISymbolicExpressionTreeNode> {
+    private string text;
+    public string Text { get { return text; } set { text = value; } }
+
+    private Font font;
+    public Font Font { get { return font; } set { font = value; } }
+
+    private Brush fontBrush;
+    public Brush FontBrush { get { return fontBrush; } set { fontBrush = value; } }
+
+    public LabeledRectangle(IChart chart, PointD lowerLeft, PointD upperRight)
+      : base(chart, lowerLeft, upperRight) {
+      font = new Font(FontFamily.GenericSansSerif, 10);
+    }
+    public LabeledRectangle(IChart chart, double x1, double y1, double x2, double y2)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2)) {
+    }
+    public LabeledRectangle(IChart chart, PointD lowerLeft, PointD upperRight, Pen pen, Brush brush)
+      : base(chart, lowerLeft, upperRight, pen, brush) {
+      font = new Font(FontFamily.GenericSansSerif, 10);
+    }
+    public LabeledRectangle(IChart chart, double x1, double y1, double x2, double y2, Pen pen, Brush brush)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2), pen, brush) {
+    }
+
+    public override void Draw(Graphics graphics) {
+      var p = Chart.TransformWorldToPixel(new PointD(LowerLeft.X, LowerLeft.Y));
+      var s = Chart.TransformWorldToPixel(Size);
+      var stringSize = graphics.MeasureString(Text, Font);
+      var fontSize = Font.Size * s.Width / stringSize.Width;
+      if (fontSize > 12) fontSize = 12; // limit maximum font size so that nodes look nicer
+      font = new Font(font.Name, fontSize, FontStyle.Regular, GraphicsUnit.Pixel);
+      stringSize = graphics.MeasureString(Text, Font);
+      graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
+      graphics.DrawString(Text, Font, FontBrush, p.X + (s.Width - stringSize.Width) / 2f, p.Y - (s.Height + stringSize.Height) / 2f);
+      base.Draw(graphics);
+    }
+
+    public ILayoutNode<ISymbolicExpressionTreeNode> Thread { get; set; }
+    public ILayoutNode<ISymbolicExpressionTreeNode> Ancestor { get; set; }
+    public ILayoutNode<ISymbolicExpressionTreeNode> Parent { get; set; }
+    public List<ILayoutNode<ISymbolicExpressionTreeNode>> Children { get; set; }
+    public float Mod { get; set; }
+    public float Prelim { get; set; }
+    public float Change { get; set; }
+    public float Shift { get; set; }
+    public int Number { get; set; }
+    public int Level { get; set; }
+    public float X { get; set; }
+    public float Y { get; set; }
+    public bool IsLeaf {
+      get { return Children == null || Children.Count == 0; }
+    }
+    public ILayoutNode<ISymbolicExpressionTreeNode> NextLeft {
+      get {
+        return Children == null ? Thread : Children.First();
+      }
+    }
+    public ILayoutNode<ISymbolicExpressionTreeNode> NextRight {
+      get {
+        return Children == null ? Thread : Children.Last();
+      }
+    }
+    public ILayoutNode<ISymbolicExpressionTreeNode> LeftSibling {
+      get {
+        if (Parent == null) return null;
+        return Number == 0 ? null : Parent.Children[Number - 1];
+      }
+    }
+    public ILayoutNode<ISymbolicExpressionTreeNode> LeftmostSibling {
+      get {
+        if (Parent == null) return null;
+        return Number == 0 ? null : Parent.Children[0];
+      }
+    }
+    public ISymbolicExpressionTreeNode Content { get; set; }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Primitives/PrimitiveGroup.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Primitives/PrimitiveGroup.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Primitives/PrimitiveGroup.cs	(revision 10265)
@@ -0,0 +1,114 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Visualization;
+
+namespace HeuristicLab.EvolutionaryTracking.Views.Primitives {
+  // a class representing a primitive group with an area defined by the LowerLeft and UpperRight points
+  // the area is important for deciding which group was selected and for layouting
+  public class PrimitiveGroup : Group, ILayoutNode<ISymbolicExpressionTree> {
+    // two points to determine the area of the primitive group
+    private PointF lowerLeft;
+    public PointF LowerLeft {
+      get { return lowerLeft; }
+      set { lowerLeft = value; }
+    }
+    private PointF upperRight;
+    public PointF UpperRight {
+      get { return upperRight; }
+      set { upperRight = value; }
+    }
+
+    public PrimitiveGroup(IChart chart)
+      : base(chart) {
+      lowerLeft = new PointF();
+      upperRight = new PointF();
+    }
+
+    public SizeF Size {
+      get { return new SizeF(upperRight.X - lowerLeft.X, upperRight.Y - lowerLeft.Y); }
+    }
+
+    public void UpdateBounds() {
+      // update corner points
+      var primitives = Primitives.Where(p => p is RectangularPrimitiveBase).Cast<RectangularPrimitiveBase>().ToList();
+      var xmin = (float)primitives.Min(p => p.LowerLeft.X);
+      var ymin = (float)primitives.Min(p => p.LowerLeft.Y);
+      LowerLeft = new PointF(xmin, ymin);
+
+      var xmax = (float)primitives.Max(p => p.UpperRight.X);
+      var ymax = (float)primitives.Max(p => p.UpperRight.Y);
+      UpperRight = new PointF(xmax, ymax);
+    }
+    public override void AddRange(IEnumerable<IPrimitive> primitives) {
+      foreach (var primitive in primitives)
+        Add(primitive);
+    }
+    public override void Move(Offset delta) {
+      base.Move(delta);
+      UpdateBounds();
+    }
+    public bool IsLeaf {
+      get { return Children == null || Children.Count == 0; }
+    }
+    public ILayoutNode<ISymbolicExpressionTree> NextLeft {
+      get {
+        return Children == null ? Thread : Children.First();
+      }
+    }
+    public ILayoutNode<ISymbolicExpressionTree> NextRight {
+      get {
+        return Children == null ? Thread : Children.Last();
+      }
+    }
+    public ILayoutNode<ISymbolicExpressionTree> LeftSibling {
+      get {
+        if (Parent == null) return null;
+        return Number == 0 ? null : Parent.Children[Number - 1];
+      }
+    }
+    public ILayoutNode<ISymbolicExpressionTree> LeftmostSibling {
+      get {
+        if (Parent == null) return null;
+        return Number == 0 ? null : Parent.Children[0];
+      }
+    }
+
+    public ILayoutNode<ISymbolicExpressionTree> Thread { get; set; }
+    public ILayoutNode<ISymbolicExpressionTree> Ancestor { get; set; }
+    public ILayoutNode<ISymbolicExpressionTree> Parent { get; set; }
+    public List<ILayoutNode<ISymbolicExpressionTree>> Children { get; set; }
+    public float Mod { get; set; }
+    public float Prelim { get; set; }
+    public float Change { get; set; }
+    public float Shift { get; set; }
+    public int Number { get; set; }
+    public int Level { get; set; }
+    public float X { get; set; }
+    public float Y { get; set; }
+
+    public ISymbolicExpressionTree Content { get; set; }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Properties/AssemblyInfo.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Properties/AssemblyInfo.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Properties/AssemblyInfo.cs	(revision 10265)
@@ -0,0 +1,36 @@
+﻿using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.EvolutionaryTracking.Views")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab.EvolutionaryTracking.Views")]
+[assembly: AssemblyCopyright("Copyright ©  2012")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("6f37d400-0cd8-4c21-adca-5537e483eed2")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Properties/Resources.Designer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Properties/Resources.Designer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Properties/Resources.Designer.cs	(revision 10265)
@@ -0,0 +1,63 @@
+﻿//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.261
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace HeuristicLab.EvolutionaryTracking.Views.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("HeuristicLab.EvolutionaryTracking.Views.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+    }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Properties/Resources.resx
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Properties/Resources.resx	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/Properties/Resources.resx	(revision 10265)
@@ -0,0 +1,120 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/VisualGenealogyGraphArc.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/VisualGenealogyGraphArc.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/VisualGenealogyGraphArc.cs	(revision 10265)
@@ -0,0 +1,86 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Drawing;
+using HeuristicLab.Visualization;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  public class VisualGenealogyGraphArc : Line {
+    public VisualGenealogyGraphNode Source;
+    public VisualGenealogyGraphNode Target;
+
+    public VisualGenealogyGraphArc(IChart chart, PointD start, PointD end)
+      : base(chart, start, end) {
+    }
+    public VisualGenealogyGraphArc(IChart chart, double x1, double y1, double x2, double y2)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2)) {
+    }
+    public VisualGenealogyGraphArc(IChart chart, PointD start, PointD end, Pen pen)
+      : base(chart, start, end, pen) {
+    }
+    public VisualGenealogyGraphArc(IChart chart, VisualGenealogyGraphNode source, VisualGenealogyGraphNode target, Pen pen)
+      : base(chart, source.Center, target.Center, pen) {
+      Source = source;
+      Target = target;
+      UpdatePosition();
+    }
+    public VisualGenealogyGraphArc(IChart chart, double x1, double y1, double x2, double y2, Pen pen)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2), pen) {
+    }
+
+    internal void UpdatePosition() {
+      if (Source.Equals(Target)) return;
+      // calculate the positions of the arc ends so that virtually the line will go through the centers of the two elliptical node shapes
+      PointD c1 = Source.Center;
+      PointD c2 = Target.Center;
+      double x = Math.Abs(c1.X - c2.X);
+      double y = Math.Abs(c1.Y - c2.Y);
+      double theta = Math.Atan(y / x); // returns angle in radians
+      // compute the intersection point between an ellipse-shaped node and a line passing through its center with the angular coordinate theta
+      PointD p1 = Source.CalculateIntersection(theta);
+      PointD p2 = Target.CalculateIntersection(theta);
+      // translate coordinates to real-world values
+      double p1X, p1Y, p2X, p2Y;
+      if (c1.X > c2.X) {
+        p1X = c1.X - p1.X;
+        p2X = c2.X + p2.X;
+      } else {
+        p1X = c1.X + p1.X;
+        p2X = c2.X - p2.X;
+      }
+      if (c1.Y > c2.Y) {
+        p1Y = c1.Y - p1.Y;
+        p2Y = c2.Y + p2.Y;
+      } else {
+        p1Y = c1.Y + p1.Y;
+        p2Y = c2.Y - p1.Y;
+      }
+      if (double.IsNaN(p1X) || double.IsNaN(p1Y) || double.IsNaN(p2X) || double.IsNaN(p2Y))
+        throw new Exception("Error calculating arc position.");
+      p1.X = p1X;
+      p1.Y = p1Y;
+      p2.X = p2X;
+      p2.Y = p2Y;
+      SetPosition(p1, p2);
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/VisualGenealogyGraphNode.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/VisualGenealogyGraphNode.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/VisualGenealogyGraphNode.cs	(revision 10265)
@@ -0,0 +1,93 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using HeuristicLab.Visualization;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  public class VisualGenealogyGraphNode : Ellipse {
+    public SymbolicExpressionTreeGenealogyGraphNode Data { get; internal set; }
+    private List<VisualGenealogyGraphArc> incomingArcs = new List<VisualGenealogyGraphArc>();
+    private List<VisualGenealogyGraphArc> outgoingArcs = new List<VisualGenealogyGraphArc>();
+
+    public List<VisualGenealogyGraphArc> IncomingArcs {
+      get { return incomingArcs; }
+      set { incomingArcs = value; }
+    }
+    public List<VisualGenealogyGraphArc> OutgoingArcs {
+      get { return outgoingArcs; }
+      set { outgoingArcs = value; }
+    }
+
+    public float LineWidth {
+      get { return Pen.Width; }
+      set { Pen.Width = value; }
+    }
+
+    public VisualGenealogyGraphNode(IChart chart, PointD lowerLeft, PointD upperRight)
+      : base(chart, lowerLeft, upperRight) {
+    }
+    public VisualGenealogyGraphNode(IChart chart, double x1, double y1, double x2, double y2)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2)) {
+    }
+    public VisualGenealogyGraphNode(IChart chart, PointD lowerLeft, PointD upperRight, Pen pen, Brush brush)
+      : base(chart, lowerLeft, upperRight, pen, brush) {
+    }
+    public VisualGenealogyGraphNode(IChart chart, double x1, double y1, double x2, double y2, Pen pen, Brush brush)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2), pen, brush) {
+    }
+
+    // compute the intersection point of an ellipse and a line passing through its center with the angular coordinate theta
+    public PointD CalculateIntersection(double theta) {
+      double sin = Math.Sin(theta);
+      double cos = Math.Cos(theta);
+      double a = Size.Width / 2;
+      double b = Size.Height / 2;
+      double r = a * b / Math.Sqrt(Math.Pow(a * sin, 2) + Math.Pow(b * cos, 2)); // radius at intersection point
+      double rx = r * cos; // X-component (relative to the origin/center of the ellipse)
+      double ry = r * sin; // Y-component (relative to the origin/center of the ellipse)
+      return new PointD(rx, ry);
+    }
+
+    public override void SetPosition(PointD lowLeft, PointD upRight) {
+      base.SetPosition(lowLeft, upRight);
+      foreach (var a in IncomingArcs) a.UpdatePosition();
+      foreach (var a in OutgoingArcs) a.UpdatePosition();
+    }
+
+    public PointD Center {
+      get { return new PointD((LowerLeft.X + UpperRight.X) / 2, (LowerLeft.Y + UpperRight.Y) / 2); }
+    }
+
+    public override void Draw(Graphics graphics) {
+      Point p = Chart.TransformWorldToPixel(new PointD(LowerLeft.X, LowerLeft.Y + Size.Height));
+      Size s = Chart.TransformWorldToPixel(Size);
+      if (Brush != null)
+        graphics.FillEllipse(Brush, p.X, p.Y, s.Width, s.Height);
+      graphics.DrawEllipse(Pen, p.X, p.Y, s.Width, s.Height);
+      if (Data.IsElite) {
+        graphics.DrawEllipse(Pen, p.X + 2, p.Y + 2, s.Width - 4, s.Height - 4);
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/VisualGenealogyGraphTextLabel.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/VisualGenealogyGraphTextLabel.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/VisualGenealogyGraphTextLabel.cs	(revision 10265)
@@ -0,0 +1,44 @@
+﻿using System.Drawing;
+using HeuristicLab.Visualization;
+using Rectangle = HeuristicLab.Visualization.Rectangle;
+
+namespace HeuristicLab.EvolutionaryTracking.Views {
+  public class VisualGenealogyGraphTextLabel : Rectangle {
+    private string text;
+    public string Text { get { return text; } set { text = value; } }
+
+    private Font font;
+    public Font Font { get { return font; } set { font = value; } }
+
+    private Brush fontBrush;
+    public Brush FontBrush { get { return fontBrush; } set { fontBrush = value; } }
+
+    public VisualGenealogyGraphTextLabel(IChart chart, PointD lowerLeft, PointD upperRight)
+      : base(chart, lowerLeft, upperRight) {
+    }
+    public VisualGenealogyGraphTextLabel(IChart chart, double x1, double y1, double x2, double y2)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2)) {
+    }
+    public VisualGenealogyGraphTextLabel(IChart chart, PointD lowerLeft, PointD upperRight, Pen pen, Brush brush)
+      : base(chart, lowerLeft, upperRight, pen, brush) {
+    }
+    public VisualGenealogyGraphTextLabel(IChart chart, double x1, double y1, double x2, double y2, Pen pen, Brush brush)
+      : this(chart, new PointD(x1, y1), new PointD(x2, y2), pen, brush) {
+    }
+
+    public override void Draw(Graphics graphics) {
+      Point p = Chart.TransformWorldToPixel(new PointD(LowerLeft.X, LowerLeft.Y + Size.Height));
+      Size s = Chart.TransformWorldToPixel(Size);
+
+      float fontSize = s.Height;
+      font = new Font(font.Name, fontSize, Font.Style, GraphicsUnit.Pixel);
+      graphics.DrawString(text, font, fontBrush, p.X, p.Y);
+    }
+
+    protected override void OnUpdate() {
+      if ((UpdateEnabled)) {
+        base.OnUpdate();
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/BuildingBlocks/Poly10BuildingBlocksAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/BuildingBlocks/Poly10BuildingBlocksAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/BuildingBlocks/Poly10BuildingBlocksAnalyzer.cs	(revision 10265)
@@ -0,0 +1,332 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using Variable = HeuristicLab.Problems.DataAnalysis.Symbolic.Variable;
+
+namespace HeuristicLab.EvolutionaryTracking.Analyzers.BuildingBlocks {
+  [StorableClass]
+  class Poly10BuildingBlocksAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string UpdateIntervalParameterName = "UpdateInterval";
+    private const string UpdateCounterParameterName = "UpdateCounter";
+    private const string ResultsParameterName = "Results";
+    private const string MatchVariablesParameterName = "MatchVariableNames";
+    private const string MatchVariableWeightsParameterName = "MatchVariableWeights";
+    private const string MatchConstantValuesParameterName = "MatchConstantValues";
+    private const string SymbolicExpressionTreeGrammarParameterName = "SymbolicExpressionTreeGrammar";
+    private const string ClonedSymbolicExpressionTreeGrammarParameterName = "ClonedSymbolicExpressionTreeGrammar";
+
+    private MaximalCommonSubsequenceCalculator maximalCommonSubsequenceCalculator;
+
+    private List<BuildingBlockGroup> buildingBlockGroups;
+
+    #region Parameters
+    public ValueParameter<IntValue> UpdateIntervalParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchVariableNamesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariablesParameterName]; }
+    }
+
+    public ValueParameter<BoolValue> MatchVariableWeightsParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariableWeightsParameterName]; }
+    }
+
+    public ValueParameter<BoolValue> MatchConstantValuesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchConstantValuesParameterName]; }
+    }
+    public IValueLookupParameter<ISymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter {
+      get { return (IValueLookupParameter<ISymbolicExpressionGrammar>)Parameters[SymbolicExpressionTreeGrammarParameterName]; }
+    }
+    public ILookupParameter<ISymbolicExpressionGrammar> ClonedSymbolicExpressionTreeGrammarParameter {
+      get { return (ILookupParameter<ISymbolicExpressionGrammar>)Parameters[ClonedSymbolicExpressionTreeGrammarParameterName]; }
+    }
+    #endregion
+
+    #region Parameter properties
+    public IntValue UpdateInterval {
+      get { return UpdateIntervalParameter.Value; }
+    }
+
+    public IntValue UpdateCounter {
+      get { return UpdateCounterParameter.Value; }
+    }
+
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public ItemArray<ISymbolicExpressionTree> SymbolicExpressionTrees {
+      get { return SymbolicExpressionTreeParameter.ActualValue; }
+    }
+    public ISymbolicExpressionGrammar SymbolicExpressionTreeGrammar {
+      get { return ClonedSymbolicExpressionTreeGrammarParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected Poly10BuildingBlocksAnalyzer(bool deserializing) : base(deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new Poly10BuildingBlocksAnalyzer(this, cloner); }
+
+    protected Poly10BuildingBlocksAnalyzer(Poly10BuildingBlocksAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      this.buildingBlockGroups = new List<BuildingBlockGroup>(original.buildingBlockGroups);
+      this.maximalCommonSubsequenceCalculator = original.maximalCommonSubsequenceCalculator;
+    }
+
+    public Poly10BuildingBlocksAnalyzer() {
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      // matching predicates      
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariablesParameterName, "Specify if the symbolic expression tree comparer should match variable names.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariableWeightsParameterName, "Specify if the symbolic expression tree comparer should match variable weights.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchConstantValuesParameterName, "Specify if the symbolic expression tree comparer should match constant values.", new BoolValue(false)));
+      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName, "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionGrammar>(ClonedSymbolicExpressionTreeGrammarParameterName, "An immutable clone of the concrete grammar that is actually used to create and manipulate trees."));
+      buildingBlockGroups = new List<BuildingBlockGroup>();
+
+      maximalCommonSubsequenceCalculator = new MaximalCommonSubsequenceCalculator();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (maximalCommonSubsequenceCalculator == null)
+        maximalCommonSubsequenceCalculator = new MaximalCommonSubsequenceCalculator();
+
+      if (buildingBlockGroups == null)
+        buildingBlockGroups = new List<BuildingBlockGroup>();
+
+      buildingBlockGroups.Clear();
+
+      if (!Parameters.ContainsKey(ClonedSymbolicExpressionTreeGrammarParameterName))
+        Parameters.Add(new LookupParameter<ISymbolicExpressionGrammar>(ClonedSymbolicExpressionTreeGrammarParameterName, "An immutable clone of the concrete grammar that is actually used to create and manipulate trees."));
+    }
+    public override void ClearState() {
+      buildingBlockGroups.Clear();
+      base.ClearState();
+    }
+
+    public bool EnabledByDefault { get; private set; }
+
+    public override IOperation Apply() {
+      UpdateCounter.Value++;
+      if (UpdateCounter.Value != UpdateInterval.Value) return base.Apply();
+      UpdateCounter.Value = 0;
+
+      if (ClonedSymbolicExpressionTreeGrammarParameter.ActualValue == null) {
+        SymbolicExpressionTreeGrammarParameter.ActualValue.ReadOnly = true;
+        IScope globalScope = ExecutionContext.Scope;
+        while (globalScope.Parent != null)
+          globalScope = globalScope.Parent;
+
+        globalScope.Variables.Add(new Core.Variable(ClonedSymbolicExpressionTreeGrammarParameterName, (ISymbolicExpressionGrammar)SymbolicExpressionTreeGrammarParameter.ActualValue.Clone()));
+      }
+
+      if (buildingBlockGroups.Count == 0)
+        PrepareFragments();
+
+      var comparer = new SymbolicExpressionTreeNodeSimilarityComparer {
+        MatchConstantValues = MatchConstantValuesParameter.Value.Value,
+        MatchVariableNames = MatchVariableNamesParameter.Value.Value,
+        MatchVariableWeights = MatchVariableWeightsParameter.Value.Value
+      };
+
+      maximalCommonSubsequenceCalculator.SimilarityComparer = comparer;
+
+      DataTable dataTable;
+      if (!Results.ContainsKey("BuildingBlocksFrequencies")) {
+        dataTable = new DataTable("BuildingBlocksFrequencies");
+        Results.Add(new Result("BuildingBlocksFrequencies", dataTable));
+        foreach (var group in buildingBlockGroups) {
+          dataTable.Rows.Add(new DataRow(group.Name) { VisualProperties = { StartIndexZero = true } });
+        }
+      } else {
+        dataTable = (DataTable)Results["BuildingBlocksFrequencies"].Value;
+      }
+
+      var canonicalSorter = new SymbolicExpressionTreeCanonicalSorter();
+      foreach (var tree in SymbolicExpressionTrees) {
+        canonicalSorter.SortSubtrees(tree);
+      }
+
+      foreach (var group in buildingBlockGroups) {
+        double frequency = 0.0;
+
+        foreach (var tree in SymbolicExpressionTrees) {
+          foreach (var bb in group.BuildingBlocks) {
+            var maxCommonSequence = maximalCommonSubsequenceCalculator.Calculate(tree.Root, bb.Fragment.Root);
+            if (maxCommonSequence.Count == bb.Fragment.Length) {
+              frequency++;
+              break;
+            }
+            canonicalSorter.SortSubtrees(bb.Fragment.Root);
+          }
+
+          //        var frequency = SymbolicExpressionTrees.Count(x => maximalCommonSubsequenceCalculator.Calculate())
+          //        var frequency = SymbolicExpressionTrees.Count(x => x.Root.ContainsFragment(bb.Fragment, comparer));
+        }
+        double relativeFrequency = frequency / SymbolicExpressionTrees.Length;
+        dataTable.Rows[group.Name].Values.Add(relativeFrequency);
+      }
+
+      return base.Apply();
+    }
+
+    private void PrepareFragments() {
+      buildingBlockGroups.Clear();
+
+      var multiplication = new Multiplication();
+      var variable = (Variable)SymbolicExpressionTreeGrammar.Symbols.First(s => s.Name.Equals("Variable"));
+      var variableNames = variable.VariableNames.ToList();
+
+      {  // (* x1 x2)
+        var n = multiplication.CreateTreeNode();
+        var x1 = new VariableTreeNode(variable) { VariableName = variableNames[0] };
+        var x2 = new VariableTreeNode(variable) { VariableName = variableNames[1] };
+        n.AddSubtree(x1);
+        n.AddSubtree(x2);
+        var bb = new BuildingBlock { Name = "(* x1 x2)", Fragment = new Fragment { Root = n } };
+        buildingBlockGroups.Add(new BuildingBlockGroup { Name = "(* x1 x2)", BuildingBlocks = new List<BuildingBlock> { bb } });
+      }
+      { // (* x3 x4)
+        var n = multiplication.CreateTreeNode();
+        var x3 = new VariableTreeNode(variable) { VariableName = variableNames[2] };
+        var x4 = new VariableTreeNode(variable) { VariableName = variableNames[3] };
+        n.AddSubtree(x3);
+        n.AddSubtree(x4);
+        var bb = new BuildingBlock { Name = "(* x3 x4)", Fragment = new Fragment { Root = n } };
+        buildingBlockGroups.Add(new BuildingBlockGroup { Name = "(* x3 x4)", BuildingBlocks = new List<BuildingBlock> { bb } });
+      }
+      {
+        // (* x5 x6)
+        var n = multiplication.CreateTreeNode();
+        var x5 = new VariableTreeNode(variable) { VariableName = variableNames[4] };
+        var x6 = new VariableTreeNode(variable) { VariableName = variableNames[5] };
+        n.AddSubtree(x5);
+        n.AddSubtree(x6);
+        var bb = new BuildingBlock { Name = "(* x5 x6)", Fragment = new Fragment { Root = n } };
+        buildingBlockGroups.Add(new BuildingBlockGroup { Name = "(* x5 x6)", BuildingBlocks = new List<BuildingBlock> { bb } });
+      }
+      {
+        var group = new BuildingBlockGroup { Name = "(* x1 x7 x9)", BuildingBlocks = new List<BuildingBlock>() };
+        {
+          // (* x1 x7 x9) => (* (* x7 x9) x1)
+          var m1 = multiplication.CreateTreeNode();
+          var m2 = multiplication.CreateTreeNode();
+          var x1 = new VariableTreeNode(variable) { VariableName = variableNames[0] };
+          var x7 = new VariableTreeNode(variable) { VariableName = variableNames[6] };
+          var x9 = new VariableTreeNode(variable) { VariableName = variableNames[8] };
+          m2.AddSubtree(x7);
+          m2.AddSubtree(x9);
+          m1.AddSubtree(m2);
+          m1.AddSubtree(x1);
+          var bb = new BuildingBlock { Name = "(* (* x7 x9) x1)", Fragment = new Fragment { Root = m1 } };
+          group.BuildingBlocks.Add(bb);
+        }
+        {
+          // (* x1 x7 x9) => (* (* x1 x9) x7)
+          var m1 = multiplication.CreateTreeNode();
+          var m2 = multiplication.CreateTreeNode();
+          var x1 = new VariableTreeNode(variable) { VariableName = variableNames[0] };
+          var x7 = new VariableTreeNode(variable) { VariableName = variableNames[6] };
+          var x9 = new VariableTreeNode(variable) { VariableName = variableNames[8] };
+          m2.AddSubtree(x1);
+          m2.AddSubtree(x9);
+          m1.AddSubtree(m2);
+          m1.AddSubtree(x7);
+          var bb = new BuildingBlock { Name = "(* (* x1 x9) x7)", Fragment = new Fragment { Root = m1 } };
+          group.BuildingBlocks.Add(bb);
+        }
+        {  // (* x1 x7 x9) => (* (* x1 x7) x9)
+          var m1 = multiplication.CreateTreeNode();
+          var m2 = multiplication.CreateTreeNode();
+          var x1 = new VariableTreeNode(variable) { VariableName = variableNames[0] };
+          var x7 = new VariableTreeNode(variable) { VariableName = variableNames[6] };
+          var x9 = new VariableTreeNode(variable) { VariableName = variableNames[8] };
+          m2.AddSubtree(x1);
+          m2.AddSubtree(x7);
+          m1.AddSubtree(m2);
+          m1.AddSubtree(x9);
+          var bb = new BuildingBlock { Name = "(* (* x1 x7) x9)", Fragment = new Fragment { Root = m1 } };
+          group.BuildingBlocks.Add(bb);
+        }
+        buildingBlockGroups.Add(group);
+      }
+      {
+        var group = new BuildingBlockGroup { Name = "(* x3 x6 x10)", BuildingBlocks = new List<BuildingBlock>() };
+        {
+          // (* x3 x6 x10) => (* (* x6 x10) x3)
+          var m1 = multiplication.CreateTreeNode();
+          var m2 = multiplication.CreateTreeNode();
+          var x3 = new VariableTreeNode(variable) { VariableName = variableNames[2] };
+          var x6 = new VariableTreeNode(variable) { VariableName = variableNames[5] };
+          var x10 = new VariableTreeNode(variable) { VariableName = variableNames[9] };
+          m2.AddSubtree(x6);
+          m2.AddSubtree(x10);
+          m1.AddSubtree(m2);
+          m1.AddSubtree(x3);
+          var bb = new BuildingBlock { Name = "(* (* x6 x10) x3)", Fragment = new Fragment { Root = m1 } };
+          group.BuildingBlocks.Add(bb);
+        }
+        {
+          // (* x3 x6 x10) => (* (* x3 x10) x6)
+          var m1 = multiplication.CreateTreeNode();
+          var m2 = multiplication.CreateTreeNode();
+          var x3 = new VariableTreeNode(variable) { VariableName = variableNames[2] };
+          var x6 = new VariableTreeNode(variable) { VariableName = variableNames[5] };
+          var x10 = new VariableTreeNode(variable) { VariableName = variableNames[9] };
+          m2.AddSubtree(x3);
+          m2.AddSubtree(x10);
+          m1.AddSubtree(m2);
+          m1.AddSubtree(x6);
+          var bb = new BuildingBlock { Name = "(* (* x3 x10) x6)", Fragment = new Fragment { Root = m1 } };
+          group.BuildingBlocks.Add(bb);
+        }
+        {
+          // (* x3 x6 x10) => (* (* x3 x6) x10)
+          var m1 = multiplication.CreateTreeNode();
+          var m2 = multiplication.CreateTreeNode();
+          var x3 = new VariableTreeNode(variable) { VariableName = variableNames[2] };
+          var x6 = new VariableTreeNode(variable) { VariableName = variableNames[5] };
+          var x10 = new VariableTreeNode(variable) { VariableName = variableNames[9] };
+          m2.AddSubtree(x3);
+          m2.AddSubtree(x6);
+          m1.AddSubtree(m2);
+          m1.AddSubtree(x10);
+          var bb = new BuildingBlock { Name = "(* (* x3 x6) x10)", Fragment = new Fragment { Root = m1 } };
+          group.BuildingBlocks.Add(bb);
+        }
+        buildingBlockGroups.Add(group);
+      }
+    }
+  }
+  internal class BuildingBlockGroup {
+    public string Name;
+    public List<BuildingBlock> BuildingBlocks;
+  }
+
+  internal class BuildingBlock {
+    public string Name;
+    public IFragment Fragment;
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/BuildingBlocks/RelevantBuildingBlocksAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/BuildingBlocks/RelevantBuildingBlocksAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/BuildingBlocks/RelevantBuildingBlocksAnalyzer.cs	(revision 10265)
@@ -0,0 +1,189 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+
+namespace HeuristicLab.EvolutionaryTracking.Analyzers.BuildingBlocks {
+  [StorableClass]
+  public class RelevantBuildingBlocksAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string UpdateIntervalParameterName = "UpdateInterval";
+    private const string UpdateCounterParameterName = "UpdateCounter";
+    private const string ResultsParameterName = "Results";
+    private const string MatchVariablesParameterName = "MatchVariableNames";
+    private const string MatchVariableWeightsParameterName = "MatchVariableWeights";
+    private const string MatchConstantValuesParameterName = "MatchConstantValues";
+    private const string SymbolicExpressionTreeGrammarParameterName = "SymbolicExpressionTreeGrammar";
+    private const string ClonedSymbolicExpressionTreeGrammarParameterName = "ClonedSymbolicExpressionTreeGrammar";
+    private const string SymbolicRegressionSolutionParameterName = "SymbolicRegressionSolution";
+    private const string PopulationGraphParameterName = "PopulationGraph";
+    private const string FrequentFragmentsTableParameterName = "FrequentFragmentsTable";
+    private const string OccurrenceFrequencyTresholdParameterName = "OccurrenceThreshold";
+
+    private readonly Dictionary<string, IFragment> foundFragments;
+
+    #region Parameters
+    public ValueParameter<IntValue> UpdateIntervalParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
+    }
+
+    public ValueParameter<IntValue> UpdateCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
+    }
+    public ValueParameter<DoubleValue> OccurrenceThresholdParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters[OccurrenceFrequencyTresholdParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchVariableNamesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariablesParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchVariableWeightsParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariableWeightsParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchConstantValuesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchConstantValuesParameterName]; }
+    }
+    public IValueLookupParameter<ISymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter {
+      get { return (IValueLookupParameter<ISymbolicExpressionGrammar>)Parameters[SymbolicExpressionTreeGrammarParameterName]; }
+    }
+    public ILookupParameter<ISymbolicExpressionGrammar> ClonedSymbolicExpressionTreeGrammarParameter {
+      get { return (ILookupParameter<ISymbolicExpressionGrammar>)Parameters[ClonedSymbolicExpressionTreeGrammarParameterName]; }
+    }
+    public ILookupParameter<ISymbolicRegressionSolution> SymbolicRegressionSolutionParameter {
+      get { return (ILookupParameter<ISymbolicRegressionSolution>)Parameters[SymbolicRegressionSolutionParameterName]; }
+    }
+    #endregion
+
+    #region Parameter properties
+    public IntValue UpdateInterval {
+      get { return UpdateIntervalParameter.Value; }
+    }
+    public IntValue UpdateCounter {
+      get { return UpdateCounterParameter.Value; }
+    }
+    public DoubleValue OccurrenceThreshold {
+      get { return OccurrenceThresholdParameter.Value; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public ItemArray<ISymbolicExpressionTree> SymbolicExpressionTrees {
+      get { return SymbolicExpressionTreeParameter.ActualValue; }
+    }
+    public ISymbolicExpressionGrammar SymbolicExpressionTreeGrammar {
+      get { return ClonedSymbolicExpressionTreeGrammarParameter.ActualValue; }
+    }
+    public ISymbolicRegressionSolution SymbolicRegressionSolution {
+      get { return SymbolicRegressionSolutionParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected RelevantBuildingBlocksAnalyzer(bool deserializing) : base(deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new RelevantBuildingBlocksAnalyzer(this, cloner); }
+
+    protected RelevantBuildingBlocksAnalyzer(RelevantBuildingBlocksAnalyzer original, Cloner cloner) : base(original, cloner) { }
+
+    public RelevantBuildingBlocksAnalyzer() {
+      #region Parameters add
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+      Parameters.Add(new ValueParameter<DoubleValue>(OccurrenceFrequencyTresholdParameterName, "The occurrence threshold for a fragment to be considered a frequenct fragment.", new DoubleValue(0.5)));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      // matching predicates      
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariablesParameterName, "Specify if the symbolic expression tree comparer should match variable names.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariableWeightsParameterName, "Specify if the symbolic expression tree comparer should match variable weights.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchConstantValuesParameterName, "Specify if the symbolic expression tree comparer should match constant values.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName, "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionGrammar>(ClonedSymbolicExpressionTreeGrammarParameterName, "An immutable clone of the concrete grammar that is actually used to create and manipulate trees."));
+      Parameters.Add(new LookupParameter<ISymbolicRegressionSolution>(SymbolicRegressionSolutionParameterName, "The symbolic regression solution."));
+      #endregion
+      foundFragments = new Dictionary<string, IFragment>();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+    }
+
+    public override void ClearState() {
+      foundFragments.Clear();
+      base.InitializeState();
+    }
+
+    public bool EnabledByDefault { get; private set; }
+
+    public override IOperation Apply() {
+      UpdateCounter.Value++;
+      if (UpdateCounter.Value != UpdateInterval.Value) return base.Apply();
+      UpdateCounter.Value = 0;
+
+      //      if (SymbolicRegressionSolution == null) return base.Apply();
+
+      var comparer = new SymbolicExpressionTreeNodeSimilarityComparer {
+        MatchConstantValues = MatchConstantValuesParameter.Value.Value,
+        MatchVariableNames = MatchVariableNamesParameter.Value.Value,
+        MatchVariableWeights = MatchVariableWeightsParameter.Value.Value
+      };
+
+      var fragmentComparer = new SymbolicExpressionTreeFragmentSimilarityComparer { SimilarityComparer = comparer };
+
+      //      var bestIndividual = SymbolicRegressionSolution.Model.SymbolicExpressionTree;
+      var bestTrainingSolution = (ISymbolicRegressionSolution)Results["Best training solution"].Value;
+      var bestIndividual = bestTrainingSolution.Model.SymbolicExpressionTree;
+      var subtrees = bestIndividual.IterateNodesPrefix().Where(node => node.SubtreeCount > 0).Select((node, index) => new { Node = node, Index = index });
+      var frequentFragments = (from s in subtrees
+                               let fragment = new Fragment { Root = s.Node, Index = s.Index }
+                               let count = SymbolicExpressionTrees.Count(tree => tree.Root.ContainsFragment(fragment, comparer))
+                               let frequency = (double)count / SymbolicExpressionTrees.Length
+                               where frequency >= OccurrenceThreshold.Value
+                               select fragment).Distinct(fragmentComparer).ToList();
+
+      var graph = (SymbolicExpressionTreeGenealogyGraph)Results[PopulationGraphParameterName].Value;
+      DataTable table;
+
+      if (!Results.ContainsKey(FrequentFragmentsTableParameterName)) {
+        table = new DataTable(FrequentFragmentsTableParameterName);
+        Results.Add(new Result(FrequentFragmentsTableParameterName, table));
+      } else {
+        table = (DataTable)Results[FrequentFragmentsTableParameterName].Value;
+      }
+
+      foreach (var fragment in foundFragments.Values) {
+        var prefixString = fragment.Root.ToPrefixString();
+        double count = SymbolicExpressionTrees.Count(t => t.Root.ContainsFragment(fragment, comparer));
+        double frequency = count / SymbolicExpressionTrees.Length;
+        table.Rows[prefixString].Values.Add(frequency);
+      }
+
+      var newFragments = frequentFragments.Where(f => !foundFragments.ContainsKey(f.Root.ToPrefixString())).ToList();
+      foreach (var fragment in newFragments) {
+        var prefixString = fragment.Root.ToPrefixString();
+        var row = new DataRow(prefixString);
+        row.Values.AddRange(from g in graph.Nodes.Where(n => n.Rank % 1 == 0).GroupBy(n => n.Rank)
+                            let count = (double)g.Count(n => n.SymbolicExpressionTree.Root.ContainsFragment(fragment, comparer))
+                            let frequency = count / SymbolicExpressionTrees.Length
+                            select frequency);
+        foundFragments.Add(prefixString, fragment);
+        table.Rows.Add(row);
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeFragmentLengthsAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeFragmentLengthsAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeFragmentLengthsAnalyzer.cs	(revision 10265)
@@ -0,0 +1,138 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+// type definitions for convenience
+using CloneMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItem>;
+using TraceMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItemList<HeuristicLab.Core.IItem>>;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// An operator that gathers information on tree fragments that get passed from one generation to the next via genetic operators
+  /// (Tracking of genetic variance and heredity)
+  /// </summary>
+  [Item("SymbolicExpressionTreeFragmentLengthAnalyzer", "An operator that provides statistics about fragment lengths")]
+  [StorableClass]
+  public sealed class SymbolicExpressionTreeFragmentLengthAnalyzer : SymbolicExpressionTreeFragmentsAnalyzer {
+    private const string FragmentLengthsParameterName = "Fragment Lengths";
+    // impact values calculator
+    public ILookupParameter<DataTable> FragmentLengthsParameter { get { return (ILookupParameter<DataTable>)Parameters[FragmentLengthsParameterName]; } }
+    public DataTable FragmentLengths {
+      get { return FragmentLengthsParameter.ActualValue; }
+      set { FragmentLengthsParameter.ActualValue = value; }
+    }
+
+    [StorableConstructor]
+    private SymbolicExpressionTreeFragmentLengthAnalyzer(bool deserializing) : base(deserializing) { }
+    private SymbolicExpressionTreeFragmentLengthAnalyzer(SymbolicExpressionTreeFragmentLengthAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreeFragmentLengthAnalyzer(this, cloner);
+    }
+    public SymbolicExpressionTreeFragmentLengthAnalyzer()
+      : base() {
+      #region Add parameters
+      Parameters.Add(new LookupParameter<DataTable>(FragmentLengthsParameterName));
+      #endregion
+
+      UpdateCounterParameter.Hidden = true;
+      UpdateIntervalParameter.Hidden = true;
+    }
+    #region After deserialization code
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+    }
+
+    #endregion
+    #region IStatefulItem members
+    public override void InitializeState() {
+      base.InitializeState();
+      UpdateCounter.Value = 0;
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+      UpdateCounter.Value = 0;
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      UpdateCounter.Value++;
+      if (UpdateCounter.Value == UpdateInterval.Value) {
+        UpdateCounter.Value = 0; // reset counter
+        if (Generations.Value > 1) {
+          SecondaryTraceMap = SecondaryTraceMap ?? new TraceMapType();
+          SecondaryFragmentMap = SecondaryFragmentMap ?? new CloneMapType();
+          SecondaryCloneMap = SecondaryCloneMap ?? new CloneMapType();
+
+          InitializeParameters();
+          InitializeRows();
+
+          var fragmentLengths = (from m in SecondaryFragmentMap
+                                 let fragment = (IFragment)m.Value
+                                 where fragment.Root != null
+                                 select fragment.Length
+                                ).ToList();
+
+          // fragments of selected offspring
+          var selected = new HashSet<ISymbolicExpressionTree>(GlobalTraceMap.Values.SelectMany(list => list.Cast<ISymbolicExpressionTree>()));
+          var goodFragmentlengths = (from m in SecondaryFragmentMap
+                                     let tree = (ISymbolicExpressionTree)m.Key
+                                     let fragment = (IFragment)m.Value
+                                     where fragment.Root != null
+                                     where selected.Contains(tree)
+                                     select fragment.Length
+                                    ).ToList();
+
+          FragmentLengths.Rows["Average fragment length (all)"].Values.Add(fragmentLengths.Count > 0 ? fragmentLengths.Average() : 0.0);
+          FragmentLengths.Rows["Average fragment length (good)"].Values.Add(goodFragmentlengths.Count > 0 ? goodFragmentlengths.Average() : 0.0);
+        }
+      }
+      return base.Apply();
+    }
+
+    protected override void InitializeParameters() {
+      var results = ResultsParameter.ActualValue;
+      if (!results.ContainsKey("Fragment lengths")) {
+        FragmentLengths = FragmentLengths ?? new DataTable("Fragment lengths") { VisualProperties = { YAxisTitle = "Number of nodes" } };
+        results.Add(new Result("Fragment lengths", FragmentLengths));
+      }
+      base.InitializeParameters();
+    }
+
+    private void InitializeRows() {
+      string[] rowNames =
+        {
+          "Average fragment length (good)", "Average fragment length (all)"
+        };
+      foreach (var rowName in rowNames.Where(rowName => !FragmentLengths.Rows.ContainsKey(rowName))) {
+        FragmentLengths.Rows.Add(new DataRow(rowName) { VisualProperties = { StartIndexZero = true } });
+      }
+    }
+  } //SymbolicExpressionTreeFragmentLengthAnalyzer
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeFragmentsAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeFragmentsAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeFragmentsAnalyzer.cs	(revision 10265)
@@ -0,0 +1,292 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+// type definitions for convenience
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+using CloneMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItem>;
+using TraceMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItemList<HeuristicLab.Core.IItem>>;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// An operator that gathers information on tree fragments that get passed from one generation to the next via genetic operators
+  /// (Tracking of genetic variance and heredity)
+  /// </summary>
+  [Item("SymbolicExpressionTreeFragmentsAnalyzer", "An operator that provides statistics about crossover fragments")]
+  [StorableClass]
+  public abstract class SymbolicExpressionTreeFragmentsAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    #region Parameter names
+    protected const string UpdateIntervalParameterName = "UpdateInterval";
+    protected const string UpdateCounterParameterName = "UpdateCounter";
+    protected const string ResultsParameterName = "Results";
+    protected const string SecondaryTraceMapParameterName = "SecondaryTraceMap";
+    protected const string SecondaryFragmentMapParameterName = "SecondaryFragmentMap";
+    protected const string SecondaryCloneMapParameterName = "SecondaryCloneMap";
+    protected const string GlobalTraceMapParameterName = "GlobalTraceMap";
+    protected const string GlobalTraceMapParameterDescription = "Global map of trees and their parents.";
+    protected const string GlobalCloneMapParameterName = "GlobalCloneMap";
+    protected const string GlobalCloneMapParameterDescription = "Global map of trees and their clones";
+    protected const string GlobalFragmentMapParameterName = "GlobalFragmentMap";
+    protected const string GlobalFragmentMapParameterDescription = "Global map of trees and their respective fragments.";
+    protected const string GenerationsParameterName = "Generations";
+    protected const string SymbolicExpressionInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
+    protected const string SymbolicRegressionProblemDataParameterName = "ProblemData";
+    #endregion
+
+    // impact values calculator
+    private readonly SymbolicRegressionSolutionImpactValuesCalculator calculator = new SymbolicRegressionSolutionImpactValuesCalculator();
+
+    #region Parameter properties
+    public ValueParameter<IntValue> UpdateIntervalParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public LookupParameter<IntValue> GenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
+    }
+    // tracking structures
+    public LookupParameter<TraceMapType> GlobalTraceMapParameter {
+      get { return (LookupParameter<TraceMapType>)Parameters[GlobalTraceMapParameterName]; }
+    }
+    public LookupParameter<CloneMapType> GlobalCloneMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[GlobalCloneMapParameterName]; }
+    }
+    public LookupParameter<CloneMapType> GlobalFragmentMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[GlobalFragmentMapParameterName]; }
+    }
+    // auxiliary structures for tracking fragments and individuals from the previous generation
+    // (this is needed because tracking is done in connection to the current generation, i.e., for 
+    // counting "successful" offspring and fragments
+    public LookupParameter<TraceMapType> SecondaryTraceMapParameter {
+      get { return (LookupParameter<TraceMapType>)Parameters[SecondaryTraceMapParameterName]; }
+    }
+    public LookupParameter<CloneMapType> SecondaryFragmentMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[SecondaryFragmentMapParameterName]; }
+    }
+    public LookupParameter<CloneMapType> SecondaryCloneMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[SecondaryCloneMapParameterName]; }
+    }
+    // problem data, interpreter and evaluator
+    public LookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter> SymbolicExpressionInterpreterParameter {
+      get { return (LookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicExpressionInterpreterParameterName]; }
+    }
+    public LookupParameter<RegressionProblemData> SymbolicRegressionProblemDataParameter {
+      get { return (LookupParameter<RegressionProblemData>)Parameters[SymbolicRegressionProblemDataParameterName]; }
+    }
+    #endregion
+
+    #region Parameters
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+    public IntValue UpdateInterval {
+      get { return UpdateIntervalParameter.Value; }
+    }
+    public IntValue UpdateCounter {
+      get { return UpdateCounterParameter.Value; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public CloneMapType GlobalCloneMap {
+      get { return GlobalCloneMapParameter.ActualValue; }
+    }
+    public TraceMapType GlobalTraceMap {
+      get { return GlobalTraceMapParameter.ActualValue; }
+    }
+    public TraceMapType SecondaryTraceMap {
+      get { return SecondaryTraceMapParameter.ActualValue; }
+      set { SecondaryTraceMapParameter.ActualValue = value; }
+    }
+    public CloneMapType SecondaryFragmentMap {
+      get { return SecondaryFragmentMapParameter.ActualValue; }
+      set { SecondaryFragmentMapParameter.ActualValue = value; }
+    }
+    public CloneMapType SecondaryCloneMap {
+      get { return SecondaryCloneMapParameter.ActualValue; }
+      set { SecondaryCloneMapParameter.ActualValue = value; }
+    }
+    public CloneMapType GlobalFragmentMap {
+      get { return GlobalFragmentMapParameter.ActualValue; }
+    }
+    public IntValue Generations {
+      get { return GenerationsParameter.ActualValue; }
+    }
+    public SymbolicDataAnalysisExpressionTreeInterpreter SymbolicExpressionInterpreter {
+      get { return SymbolicExpressionInterpreterParameter.ActualValue; }
+    }
+    public RegressionProblemData SymbolicRegressionProblemData {
+      get { return SymbolicRegressionProblemDataParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected SymbolicExpressionTreeFragmentsAnalyzer(bool deserializing) : base(deserializing) { }
+
+    protected SymbolicExpressionTreeFragmentsAnalyzer(SymbolicExpressionTreeFragmentsAnalyzer original, Cloner cloner) : base(original, cloner) { }
+
+    protected SymbolicExpressionTreeFragmentsAnalyzer()
+      : base() {
+      #region Add parameters
+      // analyzer update counter and update interval
+      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+      // tracking
+      Parameters.Add(new LookupParameter<TraceMapType>(GlobalTraceMapParameterName, GlobalTraceMapParameterDescription));
+      Parameters.Add(new LookupParameter<CloneMapType>(GlobalCloneMapParameterName, GlobalCloneMapParameterDescription));
+      Parameters.Add(new LookupParameter<CloneMapType>(GlobalFragmentMapParameterName, GlobalFragmentMapParameterDescription));
+      // secondary tracking 
+      Parameters.Add(new LookupParameter<TraceMapType>(SecondaryTraceMapParameterName, GlobalTraceMapParameterDescription));
+      Parameters.Add(new LookupParameter<CloneMapType>(SecondaryCloneMapParameterName, GlobalCloneMapParameterDescription));
+      Parameters.Add(new LookupParameter<CloneMapType>(SecondaryFragmentMapParameterName, GlobalFragmentMapParameterDescription));
+      // impact calculation
+      Parameters.Add(new LookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicExpressionInterpreterParameterName, "Interpreter for symbolic expression trees"));
+      Parameters.Add(new LookupParameter<RegressionProblemData>(SymbolicRegressionProblemDataParameterName, "The symbolic data analysis problem."));
+      // fragment statistics parameters
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
+      #endregion
+
+      UpdateCounterParameter.Hidden = true;
+      UpdateIntervalParameter.Hidden = true;
+
+    }
+    #region After deserialization code
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // check if all the parameters are present and accounted for 
+      if (!Parameters.ContainsKey(UpdateIntervalParameterName)) {
+        Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      }
+      if (!Parameters.ContainsKey(UpdateCounterParameterName)) {
+        Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+        UpdateCounterParameter.Hidden = true;
+      }
+    }
+    #endregion
+    #region IStatefulItem members
+    public override void InitializeState() {
+      base.InitializeState();
+      UpdateCounter.Value = 0;
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+      UpdateCounter.Value = 0;
+    }
+    #endregion
+
+    /* A small description of the way this analyzer works
+     * 
+     * We keep 3 maps in the global scope: the GlobalTraceMap, the GlobalFragmentMap and the GlobalCloneMap that are updated on each step: selection, crossover, mutation
+     * These maps provide information about the children, parents and transferred fragments as follows:
+     * 
+     * 1) GlobalCloneMap
+     *    This data structure provides the basis for tracking. In the selection step, every selected individual gets cloned and transferred into the recombination pool.
+     *    The GlobalCloneMap keeps track of clones by mapping them to the original individuals. This is an essential step for building the genealogy graph. Using this
+     *    structure we can find out how many times each individual was selected. 
+     *    The GlobalCloneMap consists of Key-Value pairs Clone->Original
+     *
+     * 2) GlobalTraceMap
+     *    Keeps information in the form of key-value pairs Child->{Parents}, where {Parents} is a set consisting of 
+     *      - one parent individual (in the case of mutation), by language abuse we say that the individual that mutation acted on is the parent,
+     *        and the resulting individual is the child
+     *      - two parent individuals (in the case of crossover), named Parent0 and Parent1. Parent0 is the individual that crossover acts on by replacing 
+     *        one of its subtrees with a compatible subtree, randomly selected from Parent1
+     *
+     *    CROSSOVER
+     *        Parent0     Parent1                                                                    {Parents}
+     *           \           /                                                                           ^
+     *            \       fragment (inserted from Parent1 into Parent0 to create the Child)              ^    [Mapping provided by the GlobalTraceMap]
+     *             \       /                                                                             ^
+     *              \     /                                                                              ^
+     *               Child                                                                             Child
+     *               
+     *    MUTATION
+     *        Parent0
+     *           |
+     *           |    [mutation acts on a random node/subtree in the 'parent' individual
+     *           |
+     *         Child
+     *         
+     *    Since crossover and mutation act on individuals in the recombination pool (which in fact are clones of individuals from the previous generation), the GlobalTraceMap
+     *    is populated with values given by the mappings in the GlobalCloneMap, so that the original parent for each child is known.
+     *    
+     *  3) GlobalFragmentMap
+     *     Keeps information in the form of Key-Value pairs about an individual and its respective fragment 
+     *     (ie., the subtree received via crossover or created/altered by mutation)
+     * */
+
+    public override IOperation Apply() {
+      // save the current generation so it can be compared to the following one, next time the analyzer is applied
+      SecondaryTraceMap = SecondaryTraceMap ?? new TraceMapType();
+      SecondaryCloneMap = SecondaryCloneMap ?? new CloneMapType();
+      SecondaryFragmentMap = SecondaryFragmentMap ?? new CloneMapType();
+
+      SecondaryTraceMap.Clear();
+      if (GlobalTraceMap != null)
+        foreach (var m in GlobalTraceMap)
+          SecondaryTraceMap.Add(m.Key, m.Value);
+
+      SecondaryCloneMap.Clear();
+      if (GlobalCloneMap != null)
+        foreach (var m in GlobalCloneMap)
+          SecondaryCloneMap.Add(m.Key, m.Value);
+
+      SecondaryFragmentMap.Clear();
+      if (GlobalFragmentMap != null)
+        foreach (var m in GlobalFragmentMap)
+          SecondaryFragmentMap.Add(m.Key, m.Value);
+
+      return base.Apply();
+    }
+
+    protected virtual void InitializeParameters() {
+      #region Init parameters
+
+      #endregion
+    }
+
+    private static int VisitationLength(ISymbolicExpressionTree tree) {
+      return VisitationLength(tree.Root);
+    }
+
+    private static int VisitationLength(ISymbolicExpressionTreeNode node) {
+      return node.IterateNodesBreadth().Sum(n => n.GetLength());
+    }
+
+  } //SymbolicExpressionTreeFragmentsAnalyzer
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeRelativeFragmentDepthAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeRelativeFragmentDepthAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeRelativeFragmentDepthAnalyzer.cs	(revision 10265)
@@ -0,0 +1,138 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+// type definitions for convenience
+using CloneMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItem>;
+using TraceMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItemList<HeuristicLab.Core.IItem>>;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// An operator that gathers information on tree fragments that get passed from one generation to the next via genetic operators
+  /// (Tracking of genetic variance and heredity)
+  /// </summary>
+  [Item("SymbolicExpressionTreeRelativeFragmentDepthAnalyzer", "An operator that provides statistics about crossover fragments")]
+  [StorableClass]
+  public sealed class SymbolicExpressionTreeRelativeFragmentDepthAnalyzer : SymbolicExpressionTreeFragmentsAnalyzer {
+    private const string RelativeFragmentDepthParameterName = "Relative fragment depth";
+    public ILookupParameter<DataTable> RelativeFragmentDepthParameter { get { return (ILookupParameter<DataTable>)Parameters[RelativeFragmentDepthParameterName]; } }
+
+    public DataTable RelativeFragmentDepths {
+      get { return RelativeFragmentDepthParameter.ActualValue; }
+      set { RelativeFragmentDepthParameter.ActualValue = value; }
+    }
+
+    [StorableConstructor]
+    private SymbolicExpressionTreeRelativeFragmentDepthAnalyzer(bool deserializing) : base(deserializing) { }
+    private SymbolicExpressionTreeRelativeFragmentDepthAnalyzer(SymbolicExpressionTreeRelativeFragmentDepthAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreeRelativeFragmentDepthAnalyzer(this, cloner);
+    }
+    public SymbolicExpressionTreeRelativeFragmentDepthAnalyzer()
+      : base() {
+      #region Add parameters
+      Parameters.Add(new LookupParameter<DataTable>(RelativeFragmentDepthParameterName));
+      #endregion
+
+      UpdateCounterParameter.Hidden = true;
+      UpdateIntervalParameter.Hidden = true;
+
+    }
+    #region After deserialization code
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+    }
+
+    #endregion
+    #region IStatefulItem members
+    public override void InitializeState() {
+      base.InitializeState();
+      UpdateCounter.Value = 0;
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+      UpdateCounter.Value = 0;
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      UpdateCounter.Value++;
+      if (UpdateCounter.Value == UpdateInterval.Value) {
+        UpdateCounter.Value = 0; // reset counter
+        if (Generations.Value > 1) {
+          SecondaryTraceMap = SecondaryTraceMap ?? new TraceMapType();
+          SecondaryFragmentMap = SecondaryFragmentMap ?? new CloneMapType();
+          SecondaryCloneMap = SecondaryCloneMap ?? new CloneMapType();
+
+          InitializeParameters();
+          InitializeRows();
+
+          var fragmentDepths = (from m in SecondaryFragmentMap
+                                let tree = (ISymbolicExpressionTree)m.Key
+                                let fragment = (IFragment)m.Value
+                                where fragment.Root != null
+                                select tree.Root.GetBranchLevel(fragment.Root)
+                               ).ToList();
+
+          // fragments of selected offspring
+          var selected = new HashSet<ISymbolicExpressionTree>(GlobalTraceMap.Values.SelectMany(list => list.Cast<ISymbolicExpressionTree>()));
+          var goodFragmentDepths = (from m in SecondaryFragmentMap
+                                    let tree = (ISymbolicExpressionTree)m.Key
+                                    let fragment = (IFragment)m.Value
+                                    where fragment.Root != null
+                                    where selected.Contains(tree)
+                                    select tree.Root.GetBranchLevel(fragment.Root)
+                                   ).ToList();
+
+          RelativeFragmentDepths.Rows["Average relative fragment depth (all)"].Values.Add(fragmentDepths.Count > 0 ? fragmentDepths.Average() : 0.0);
+          RelativeFragmentDepths.Rows["Average relative fragment depth (good)"].Values.Add(goodFragmentDepths.Count > 0 ? goodFragmentDepths.Average() : 0.0);
+        }
+      }
+      return base.Apply();
+    }
+
+    protected override void InitializeParameters() {
+      var results = ResultsParameter.ActualValue;
+      if (!results.ContainsKey("Relative fragment depths")) {
+        RelativeFragmentDepths = RelativeFragmentDepths ?? new DataTable("Relative fragment depths") { VisualProperties = { YAxisTitle = "Relative depth" } };
+        results.Add(new Result("Relative fragment depths", RelativeFragmentDepths));
+      }
+      base.InitializeParameters();
+    }
+
+    private void InitializeRows() {
+      string[] rowNames = { "Average relative fragment depth (good)", "Average relative fragment depth (all)" };
+      foreach (var rowName in rowNames.Where(rowName => !RelativeFragmentDepths.Rows.ContainsKey(rowName))) {
+        RelativeFragmentDepths.Rows.Add(new DataRow(rowName) { VisualProperties = { StartIndexZero = true } });
+      }
+    }
+  } //SymbolicExpressionTreeFragmentLengthAnalyzer
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicDataAnalysisSolutionPruningOptimizer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicDataAnalysisSolutionPruningOptimizer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicDataAnalysisSolutionPruningOptimizer.cs	(revision 10265)
@@ -0,0 +1,121 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [Item("SymbolicDataAnalysisSolutionPruningOptimizer", "An operator which automatically removes nodes that have a negative impact from the tree model, optimizing the remaining constants.")]
+  [StorableClass]
+  public class SymbolicDataAnalysisSolutionPruningOptimizer : SingleSuccessorOperator, IAnalyzer {
+    private const string ResultCollectionParameterName = "Results";
+    private const string TrainingBestSolutionParameterName = "Best training solution";
+
+    #region parameter properties
+    public ILookupParameter<ResultCollection> ResultCollectionParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters[ResultCollectionParameterName]; }
+    }
+    #endregion
+    #region properties
+    public ResultCollection ResultCollection {
+      get { return ResultCollectionParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected SymbolicDataAnalysisSolutionPruningOptimizer(bool deserializing) : base(deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicDataAnalysisSolutionPruningOptimizer(this, cloner);
+    }
+
+    protected SymbolicDataAnalysisSolutionPruningOptimizer(SymbolicDataAnalysisSolutionPruningOptimizer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public SymbolicDataAnalysisSolutionPruningOptimizer() {
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultCollectionParameterName));
+    }
+
+    public override IOperation Apply() {
+      var solution = (ISymbolicRegressionSolution)ResultCollection[TrainingBestSolutionParameterName].Value;
+      ResultCollection[TrainingBestSolutionParameterName].Value = PruneAndOptimizeSolution(solution);
+      return base.Apply();
+    }
+
+    public ISymbolicDataAnalysisSolution PruneAndOptimizeSolution(ISymbolicRegressionSolution solution) {
+      return PruneAndOptimizeRegressionSolution(solution);
+    }
+
+    private static ISymbolicRegressionSolution PruneAndOptimizeRegressionSolution(ISymbolicRegressionSolution solution) {
+      var calculator = new SymbolicRegressionSolutionImpactValuesCalculator();
+      var model = solution.Model;
+      var problemData = solution.ProblemData;
+      // get tree levels and iterate each level from the bottom up
+      var root = model.SymbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0);
+      var levels = root.IterateNodesBreadth().GroupBy(root.GetBranchLevel).OrderByDescending(g => g.Key);
+
+      foreach (var level in levels) {
+        bool stop = false;
+        while (!stop) {
+          var tuple = level.Select(n => new { Node = n, Impact = calculator.CalculateImpactValue(model, n, problemData, problemData.TrainingIndices) }).OrderBy(x => x.Impact).First();
+          var node = tuple.Node;
+          var impact = tuple.Impact;
+          if (impact < 0) {
+            var replacementValue = calculator.CalculateReplacementValue(model, node, problemData,
+              problemData.TrainingIndices);
+            var constantNode = MakeConstantTreeNode(replacementValue);
+            var parent = node.Parent;
+            var index = parent.IndexOfSubtree(node);
+            parent.RemoveSubtree(index);
+            parent.InsertSubtree(index, constantNode);
+            SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(model.Interpreter,
+              model.SymbolicExpressionTree, problemData, problemData.TrainingIndices, true, 50,
+              model.UpperEstimationLimit,
+              model.LowerEstimationLimit);
+            continue;
+          }
+          stop = true;
+        }
+      }
+      var newSolution = (ISymbolicRegressionSolution)model.CreateRegressionSolution(problemData);
+      return newSolution.TrainingRSquared > solution.TrainingRSquared ? newSolution : solution;
+    }
+
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+
+    private static ConstantTreeNode MakeConstantTreeNode(double value) {
+      var constant = new Constant { MinValue = value - 1, MaxValue = value + 1 };
+      var constantTreeNode = (ConstantTreeNode)constant.CreateTreeNode();
+      constantTreeNode.Value = value;
+      return constantTreeNode;
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeEvolvabilityAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeEvolvabilityAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeEvolvabilityAnalyzer.cs	(revision 10265)
@@ -0,0 +1,294 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// Evolvability Analyzer
+  /// </summary>
+  [Item("SymbolicExpressionEvolvabilityAnalyzer", "An operator that measures relative improvements obtained by genetic operators and relative reproductive success.")]
+  [StorableClass]
+  public sealed class SymbolicExpressionEvolvabilityAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    #region Parameter names
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string SymbolicExpressionTreeQualityParameterName = "Quality";
+    private const string UpdateIntervalParameterName = "UpdateInterval";
+    private const string UpdateCounterParameterName = "UpdateCounter";
+    private const string ResultsParameterName = "Results";
+    private const string PopulationGraphParameterName = "PopulationGraph";
+    private const string PopulationSizeParameterName = "PopulationSize";
+    private const string ElitesParameterName = "Elites";
+    private const string RelativeReproductiveSuccessResultName = "RelativeReproductiveSuccess";
+    private const string GeneticOperatorsAverageImprovementResultName = "GeneticOperatorsAverageImprovement";
+    private const string ConstantOptimizationIntermediateParentsParameterName = "ConstantOptimizeIntermediateParents";
+    private const string ConstantOptimizationEvaluatorParameterName = "ConstantOptimizationOperator";
+    private const string RandomParameterName = "Random";
+    #endregion
+
+    #region Parameter properties
+    public LookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters[RandomParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateIntervalParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
+    }
+    public ValueParameter<BoolValue> ConstantOptimizationIntermediateParentsParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[ConstantOptimizationIntermediateParentsParameterName]; }
+    }
+    public IFixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator> ConstantOptimizationEvaluatorParameter {
+      get { return (IFixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator>)Parameters[ConstantOptimizationEvaluatorParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> SymbolicExpressionTreeQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[SymbolicExpressionTreeQualityParameterName]; }
+    }
+    public LookupParameter<IntValue> ElitesParameter {
+      get { return (LookupParameter<IntValue>)Parameters[ElitesParameterName]; }
+    }
+    public LookupParameter<IntValue> PopulationSizeParameter {
+      get { return (LookupParameter<IntValue>)Parameters[PopulationSizeParameterName]; }
+    }
+    #endregion
+
+    #region Parameters
+    public IntValue UpdateInterval {
+      get { return UpdateIntervalParameter.Value; }
+    }
+    public IntValue UpdateCounter {
+      get { return UpdateCounterParameter.Value; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public IntValue PopulationSize {
+      get { return PopulationSizeParameter.ActualValue; }
+    }
+    public IntValue Elites {
+      get { return ElitesParameter.ActualValue; }
+    }
+    public BoolValue ConstantOptimizationIntermediateParents {
+      get { return ConstantOptimizationIntermediateParentsParameter.Value; }
+    }
+    public SymbolicRegressionConstantOptimizationEvaluator ConstantOptimizationEvaluator {
+      get { return ConstantOptimizationEvaluatorParameter.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicExpressionEvolvabilityAnalyzer(bool deserializing) : base(deserializing) { }
+    private SymbolicExpressionEvolvabilityAnalyzer(SymbolicExpressionEvolvabilityAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new SymbolicExpressionEvolvabilityAnalyzer(this, cloner); }
+
+    public SymbolicExpressionEvolvabilityAnalyzer() {
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(SymbolicExpressionTreeQualityParameterName, "The qualities of the symbolic expression trees"));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new LookupParameter<IntValue>(PopulationSizeParameterName, "The population size."));
+      Parameters.Add(new LookupParameter<IntValue>(ElitesParameterName, "Number of elites in the population."));
+      Parameters.Add(new ValueParameter<BoolValue>(ConstantOptimizationIntermediateParentsParameterName, "Controls whether or not the constant values of the intermediate nodes should be updated.", new BoolValue(false)));
+      Parameters.Add(new ValueLookupParameter<IRandom>(RandomParameterName, "The random generator to use."));
+      Parameters.Add(new FixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator>(ConstantOptimizationEvaluatorParameterName, "The operator used to perform the constant optimization"));
+
+      UpdateCounterParameter.Hidden = true;
+      UpdateIntervalParameter.Hidden = true;
+
+      //Changed the ActualName of the EvaluationPartitionParameter so that it matches the parameter name of symbolic regression problems.
+      ConstantOptimizationEvaluator.EvaluationPartitionParameter.ActualName = "FitnessCalculationPartition";
+      ConstantOptimizationEvaluator.UpdateConstantsInTree = false;
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ConstantOptimizationEvaluatorParameterName)) {
+        Parameters.Add(new FixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator>(ConstantOptimizationEvaluatorParameterName, "The operator used to perform the constant optimization"));
+        //Changed the ActualName of the EvaluationPartitionParameter so that it matches the parameter name of symbolic regression problems.
+        ConstantOptimizationEvaluator.EvaluationPartitionParameter.ActualName = "FitnessCalculationPartition";
+        ConstantOptimizationEvaluator.UpdateConstantsInTree = false;
+      }
+
+      if (!Parameters.ContainsKey(ConstantOptimizationIntermediateParentsParameterName))
+        Parameters.Add(new ValueParameter<BoolValue>(ConstantOptimizationIntermediateParentsParameterName, "Controls whether or not the constant values of the intermediate parents should be updated.", new BoolValue(false)));
+    }
+
+    #region IStatefulItem members
+    public override void InitializeState() {
+      base.InitializeState();
+      UpdateCounter.Value = 0;
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+      UpdateCounter.Value = 0;
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      UpdateCounter.Value++;
+
+      if (UpdateCounter.Value == UpdateInterval.Value) {
+        UpdateCounter.Value = 0;
+        if (!Results.ContainsKey(PopulationGraphParameterName)) return base.Apply();
+        var genealogyGraph = (SymbolicExpressionTreeGenealogyGraph)Results[PopulationGraphParameterName].Value;
+        if (genealogyGraph == null) return base.Apply();
+
+        ISymbolicExpressionTree[] trees = SymbolicExpressionTreeParameter.ActualValue.ToArray();
+        var currentGen = (from tree in trees
+                          select genealogyGraph.GetGraphNodes(tree).Last()).Where(n => n.InEdges != null).ToList();
+        var intermediateGen = (from graphNode in currentGen
+                               where graphNode.InEdges.Count == 1
+                               // mutation
+                               let source = (SymbolicExpressionTreeGenealogyGraphNode)graphNode.InEdges[0].Source
+                               where graphNode.SymbolicExpressionTree != source.SymbolicExpressionTree // skip elites
+                               select source).ToList();
+        // currentGen will contain nodes corresponding to individuals in the current generation
+        // + intermediate individuals (that were created via crossover, then mutated)
+        currentGen.AddRange(intermediateGen);
+        currentGen.Sort((a, b) => b.InEdges.Count.CompareTo(a.InEdges.Count)); // sort by InEdge count descending so that crossover offspring are first in the list
+
+        int successfulOffspring = 0;
+        var crossoverImprovements = new List<double>();
+        var mutationImprovements = new List<double>();
+
+        foreach (var graphNode in currentGen) {
+          var quality = graphNode.Quality;
+          double parentQuality = 0.0;
+          if (graphNode.InEdges == null) throw new Exception("InEdges should not be null.");
+          switch (graphNode.InEdges.Count) {
+            case 2: {
+                parentQuality = graphNode.InEdges.Max(e => ((SymbolicExpressionTreeGenealogyGraphNode)e.Source).Quality);
+                crossoverImprovements.Add(quality - parentQuality);
+                break;
+              }
+            case 1: {
+                parentQuality = graphNode.InEdges.Max(e => ((SymbolicExpressionTreeGenealogyGraphNode)e.Source).Quality);
+                if (ConstantOptimizationIntermediateParents.Value && ConstantOptimizationEvaluator != null) {
+
+                  //Get the optimized fitness of the intermediate parent (without actually updating the constants in the tree)
+                  var intermediateParent = ((SymbolicExpressionTreeGenealogyGraphNode)graphNode.InEdges[0].Source).SymbolicExpressionTree;
+                  parentQuality = Evaluate(intermediateParent, ConstantOptimizationEvaluator);
+                }
+                mutationImprovements.Add(quality - parentQuality);
+                break;
+              }
+          }
+          if (quality > parentQuality)
+            successfulOffspring++;
+        }
+        // reproductive success
+        double reproductiveSuccess = (double)successfulOffspring / (PopulationSize.Value - Elites.Value);
+        const string reproductiveSuccessDataTableName = "Reproductive success";
+        if (!Results.ContainsKey(RelativeReproductiveSuccessResultName))
+          Results.Add(new Result(RelativeReproductiveSuccessResultName, new DataTable(reproductiveSuccessDataTableName)));
+        var relativeReproductiveSuccessTable = (DataTable)Results[RelativeReproductiveSuccessResultName].Value;
+        if (!relativeReproductiveSuccessTable.Rows.ContainsKey(reproductiveSuccessDataTableName))
+          relativeReproductiveSuccessTable.Rows.Add(new DataRow(reproductiveSuccessDataTableName) { VisualProperties = { StartIndexZero = true } });
+        relativeReproductiveSuccessTable.Rows[reproductiveSuccessDataTableName].Values.Add(reproductiveSuccess);
+
+        // average and relative number of leaf nodes
+        if (!Results.ContainsKey("RelativeProportionOfLeafNodes"))
+          Results.Add(new Result("RelativeProportionOfLeafNodes", new DataTable("Proportion of leaf nodes")));
+        var relativeProportionOfLeafNodesTable = (DataTable)Results["RelativeProportionOfLeafNodes"].Value;
+        if (!relativeProportionOfLeafNodesTable.Rows.ContainsKey("Percent of leaf nodes"))
+          relativeProportionOfLeafNodesTable.Rows.Add(new DataRow("Percent of leaf nodes") { VisualProperties = { StartIndexZero = true } });
+        if (!relativeProportionOfLeafNodesTable.Rows.ContainsKey("Average number of leafs"))
+          relativeProportionOfLeafNodesTable.Rows.Add(new DataRow("Average number of leafs") { VisualProperties = { StartIndexZero = true } });
+
+        double totalNodes = trees.Sum(x => x.Length);
+        double totalLeafs = trees.Sum(t => t.IterateNodesPostfix().Count(n => n.SubtreeCount == 0));
+
+        relativeProportionOfLeafNodesTable.Rows["Percent of leaf nodes"].Values.Add(totalLeafs / totalNodes);
+        relativeProportionOfLeafNodesTable.Rows["Average number of leafs"].Values.Add(totalLeafs / trees.Length);
+
+        // genetic operators best and average improvement values
+        if (!Results.ContainsKey(GeneticOperatorsAverageImprovementResultName)) {
+          Results.Add(new Result(GeneticOperatorsAverageImprovementResultName, new DataTable()));
+        }
+        var table = (DataTable)Results[GeneticOperatorsAverageImprovementResultName].Value;
+
+        double cxAvgImprovement = 0.0;
+        double cxMaxImprovement = 0.0;
+        if (crossoverImprovements.Count > 0) {
+          cxAvgImprovement = crossoverImprovements.Average();
+          cxMaxImprovement = crossoverImprovements.Max();
+        }
+        double mutAvgImprovement = 0.0;
+        double mutMaxImprovement = 0.0;
+        if (mutationImprovements.Count > 0) {
+          mutAvgImprovement = mutationImprovements.Average();
+          mutMaxImprovement = mutationImprovements.Max();
+        }
+
+        if (!table.Rows.ContainsKey("Average crossover improvement")) {
+          table.Rows.Add(new DataRow("Average crossover improvement") { VisualProperties = { StartIndexZero = true } });
+        }
+        table.Rows["Average crossover improvement"].Values.Add(cxAvgImprovement);
+
+        if (!table.Rows.ContainsKey("Average mutation improvement")) {
+          table.Rows.Add(new DataRow("Average mutation improvement") { VisualProperties = { StartIndexZero = true } });
+        }
+        table.Rows["Average mutation improvement"].Values.Add(mutAvgImprovement);
+
+        if (!table.Rows.ContainsKey("Best crossover improvement")) {
+          table.Rows.Add(new DataRow("Best crossover improvement") { VisualProperties = { StartIndexZero = true } });
+        }
+        table.Rows["Best crossover improvement"].Values.Add(cxMaxImprovement);
+
+        if (!table.Rows.ContainsKey("Best mutation improvement")) {
+          table.Rows.Add(new DataRow("Best mutation improvement") { VisualProperties = { StartIndexZero = true } });
+        }
+        table.Rows["Best mutation improvement"].Values.Add(mutMaxImprovement);
+
+        if (!table.Rows.ContainsKey("Average improvement")) {
+          table.Rows.Add(new DataRow("Average improvement") { VisualProperties = { StartIndexZero = true } });
+        }
+        table.Rows["Average improvement"].Values.Add((cxAvgImprovement + mutAvgImprovement) / 2);
+
+        if (!table.Rows.ContainsKey("Best improvement")) {
+          table.Rows.Add(new DataRow("Best improvement") { VisualProperties = { StartIndexZero = true } });
+        }
+        table.Rows["Best improvement"].Values.Add(Math.Max(cxMaxImprovement, mutMaxImprovement));
+      }
+      return base.Apply();
+    }
+
+    /// <summary>
+    /// Evaluate a symbolic expression tree. We perform evaluation by adding a temporary subscope with the tree in it, and calling evaluator.Apply()
+    /// </summary>
+    /// <param name="tree">The symbolic expression tree to evaluate</param>
+    /// <param name="evaluator">The symbolic regression single objective evaluator to use</param>
+    /// <returns>A double value representing the fitness</returns>
+    private double Evaluate(IItem tree, SymbolicRegressionSingleObjectiveEvaluator evaluator) {
+      var subScope = new Scope();
+      subScope.Variables.Add(new Variable("SymbolicExpressionTree", tree)); // inject expected variables into the subscope
+      ExecutionContext.Scope.SubScopes.Add(subScope);
+      var context = new Core.ExecutionContext(ExecutionContext, evaluator, subScope);
+      evaluator.Execute(context, new CancellationToken()); // call evaluator.Apply()
+      double quality = ((DoubleValue)subScope.Variables["Quality"].Value).Value; // get the quality
+      ExecutionContext.Scope.SubScopes.Remove(subScope); // remove the subscope
+      return quality;
+    }
+
+    public bool EnabledByDefault { get { return true; } }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeFrequentPatternsAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeFrequentPatternsAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeFrequentPatternsAnalyzer.cs	(revision 10265)
@@ -0,0 +1,373 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// An analyzer that looks at individual lineages in the genealogy graph
+  /// </summary>
+  [Item("SymbolicExpressionTreeFrequentPatternsAnalyzer", "An operator that tries to find frequent tree fragments in the population")]
+  [StorableClass]
+  public sealed class SymbolicExpressionTreeFrequentPatternsAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    #region Parameter names
+    private const string UpdateIntervalParameterName = "UpdateInterval";
+    private const string UpdateCounterParameterName = "UpdateCounter";
+    private const string ResultsParameterName = "Results";
+    private const string GenerationsParameterName = "Generations";
+    private const string MaximumGenerationsParameterName = "MaximumGenerations";
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string RandomParameterName = "Random";
+    private const string MaximumFragmentDepthParameterName = "MaximumFragmentDepth";
+    private const string MaximumFragmentLengthParameterName = "MaximumFragmentLength";
+    private const string NumberOfFragmentsToGenerateParameterName = "NumberOfFragmentsToGenerate";
+    private const string FrequentFragmentOccurrenceThresholdParameterName = "FrequentFragmentOccurrenceThreshold";
+    private const string PopulationGraphParameterName = "PopulationGraph";
+    private const string CommonFragmentsParameterName = "CommonFragments";
+    private const string EnforceGrammarArityParameterName = "EnforceGrammarArity";
+    #endregion
+
+    #region Parameter properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters[RandomParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateIntervalParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public LookupParameter<IntValue> GenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
+    }
+    public LookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[MaximumGenerationsParameterName]; }
+    }
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public ValueParameter<IntValue> MaximumFragmentDepthParameter {
+      get { return (ValueParameter<IntValue>)Parameters[MaximumFragmentDepthParameterName]; }
+    }
+    public ValueParameter<IntValue> MaximumFragmentLengthParameter {
+      get { return (ValueParameter<IntValue>)Parameters[MaximumFragmentLengthParameterName]; }
+    }
+    public ValueParameter<IntValue> NumberOfFragmentsToGenerateParameter {
+      get { return (ValueParameter<IntValue>)Parameters[NumberOfFragmentsToGenerateParameterName]; }
+    }
+    public ValueParameter<DoubleValue> FrequentFragmentOccurrenceThresholdParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters[FrequentFragmentOccurrenceThresholdParameterName]; }
+    }
+    public ValueParameter<BoolValue> EnforceGrammarArityParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[EnforceGrammarArityParameterName]; }
+    }
+    #endregion
+    #region Properties
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+    public IntValue UpdateInterval {
+      get { return UpdateIntervalParameter.Value; }
+    }
+    public IntValue UpdateCounter {
+      get { return UpdateCounterParameter.Value; }
+    }
+    public IntValue Generations {
+      get { return GenerationsParameter.ActualValue; }
+    }
+    public IntValue MaximumGenerations {
+      get { return MaximumGenerationsParameter.ActualValue; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public IntValue MaximumFragmentDepth {
+      get { return MaximumFragmentDepthParameter.Value; }
+    }
+    public IntValue MaximumFragmentLength {
+      get { return MaximumFragmentLengthParameter.Value; }
+    }
+    public IntValue NumberOfFragmentsToGenerate {
+      get { return NumberOfFragmentsToGenerateParameter.Value; }
+    }
+    public DoubleValue FrequentFragmentOccurrenceThreshold {
+      get { return FrequentFragmentOccurrenceThresholdParameter.Value; }
+    }
+    public BoolValue EnforceGrammarArity {
+      get { return EnforceGrammarArityParameter.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicExpressionTreeFrequentPatternsAnalyzer(bool deserializing) : base(deserializing) { }
+    private SymbolicExpressionTreeFrequentPatternsAnalyzer(SymbolicExpressionTreeFrequentPatternsAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreeFrequentPatternsAnalyzer(this, cloner);
+    }
+    public SymbolicExpressionTreeFrequentPatternsAnalyzer() {
+      #region Add parameters
+      Parameters.Add(new LookupParameter<IRandom>(RandomParameterName, "The random number generator to use."));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
+      Parameters.Add(new ValueParameter<IntValue>(MaximumFragmentDepthParameterName, "The maximum allowed depth for generated fragments.", new IntValue(4)));
+      Parameters.Add(new ValueParameter<IntValue>(MaximumFragmentLengthParameterName, "The maximum allowed length for generated fragments.", new IntValue(15)));
+      Parameters.Add(new ValueParameter<IntValue>(NumberOfFragmentsToGenerateParameterName, "The number of fragments to generate.", new IntValue(1000)));
+      Parameters.Add(new ValueParameter<DoubleValue>(FrequentFragmentOccurrenceThresholdParameterName, "Occurrence used to discriminate frequent fragments.", new DoubleValue(0.3)));
+      Parameters.Add(new ValueParameter<BoolValue>(EnforceGrammarArityParameterName, "Whether to use minimum arity as defined by the grammar", new BoolValue(true)));
+      #endregion
+      UpdateCounterParameter.Hidden = true;
+      UpdateIntervalParameter.Hidden = true;
+      MaximumFragmentDepthParameter.Hidden = false;
+      MaximumFragmentLengthParameter.Hidden = false;
+
+      //this.Successor = new SymbolicExpressionTreeGenealogyGraphBuilder();
+    }
+
+    #region AfterDeserialization
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(MaximumFragmentDepthParameterName)) {
+        Parameters.Add(new ValueParameter<IntValue>(MaximumFragmentDepthParameterName, "The maximum allowed depth for generated fragments.", new IntValue(4)));
+      }
+      if (!Parameters.ContainsKey(MaximumFragmentLengthParameterName)) {
+        Parameters.Add(new ValueParameter<IntValue>(MaximumFragmentLengthParameterName, "The maximum allowed length for generated fragments.", new IntValue(15)));
+      }
+      if (!Parameters.ContainsKey(NumberOfFragmentsToGenerateParameterName)) {
+        Parameters.Add(new ValueParameter<IntValue>(NumberOfFragmentsToGenerateParameterName, "The number of fragments to generate.", new IntValue(1000)));
+      }
+      if (!Parameters.ContainsKey(FrequentFragmentOccurrenceThresholdParameterName)) {
+        Parameters.Add(new ValueParameter<DoubleValue>(FrequentFragmentOccurrenceThresholdParameterName, "Occurrence used to discriminate frequent fragments.", new DoubleValue(0.3)));
+      }
+      if (!Parameters.ContainsKey(EnforceGrammarArityParameterName)) {
+        Parameters.Add(new ValueParameter<BoolValue>(EnforceGrammarArityParameterName, "Whether to use minimum arity as defined by the grammar", new BoolValue(true)));
+      }
+    }
+    #endregion
+
+    #region IStatefulItem members
+    public override void InitializeState() {
+      base.InitializeState();
+      UpdateCounter.Value = 0;
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+      UpdateCounter.Value = 0;
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      UpdateCounter.Value++;
+      if (UpdateCounter.Value == UpdateInterval.Value) {
+        if (!Results.ContainsKey("SymbolGraph")) return base.Apply();
+
+        UpdateCounter.Value = 0;
+
+        var trees = SymbolicExpressionTreeParameter.ActualValue.ToList();
+        var grammar = trees[0].Root.Grammar;
+
+        var graph = Results["SymbolGraph"].Value as SymbolGraph;
+
+        var similarityComparer = new SymbolicExpressionTreeNodeSimilarityComparer { MatchVariableNames = true };
+        var fragmentSimilarityComparer = new SymbolicExpressionTreeFragmentSimilarityComparer { SimilarityComparer = similarityComparer };
+        // generate fragments out of the probability graph and match them against the population
+        var fragments = GenerateFragments(graph, grammar, NumberOfFragmentsToGenerate.Value, MaximumFragmentDepth.Value, MaximumFragmentLength.Value).ToList();
+        // subtree-sort fragments to bring them to a canonical form
+        // var canonicalSorter = new SymbolicExpressionTreeCanonicalSorter();
+
+        if (!Results.ContainsKey(CommonFragmentsParameterName)) {
+          Results.Add(new Result(CommonFragmentsParameterName, new ItemDictionary<IFragment, DoubleValue>()));
+        }
+
+        var mostCommonFragmentsResult = Results[CommonFragmentsParameterName].Value as ItemDictionary<IFragment, DoubleValue>; // should never be null
+        var mostCommonFragments = mostCommonFragmentsResult.Select(x => x.Key).ToList();
+        mostCommonFragments.AddRange(fragments);
+        mostCommonFragmentsResult.Clear();
+
+        mostCommonFragments = mostCommonFragments.Distinct(fragmentSimilarityComparer).ToList();
+
+        foreach (var fragment in mostCommonFragments) {
+          var frequency = trees.Count(x => x.Root.ContainsFragment(fragment, similarityComparer)) / (double)trees.Count;
+          if (frequency > 0) mostCommonFragmentsResult.Add(fragment, new DoubleValue(frequency));
+        }
+
+        // update fragment frequencies DataTable
+        if (!Results.ContainsKey("FrequentFragments")) {
+          var dt = new DataTable("Frequent Fragments");
+          Results.Add(new Result("FrequentFragments", dt));
+        }
+
+        var fragmentFrequenciesTable = Results["FrequentFragments"].Value as DataTable; // should never be null
+        foreach (var fragment in mostCommonFragmentsResult) {
+          var prefixString = fragment.Key.Root.ToPrefixString();
+          if (!fragmentFrequenciesTable.Rows.ContainsKey(prefixString)) {
+            if (fragment.Value.Value > FrequentFragmentOccurrenceThreshold.Value) {
+              fragmentFrequenciesTable.Rows.Add(new DataRow(prefixString) { VisualProperties = { StartIndexZero = true } });
+              var row = fragmentFrequenciesTable.Rows[prefixString];
+              if (!Results.ContainsKey(PopulationGraphParameterName)) {
+                row.Values.AddRange(Enumerable.Repeat(0.0, Generations.Value));
+              } else {
+                var populationGraph = Results[PopulationGraphParameterName].Value as SymbolicExpressionTreeGenealogyGraph;
+                var layers = populationGraph.Nodes.Where(n => n.Rank % 1 == 0).GroupBy(n => n.Rank).OrderBy(g => g.Key);
+                var f = fragment;
+                row.Values.AddRange(from g in layers
+                                    select g.Count(n => n.SymbolicExpressionTree.Root.ContainsFragment(f.Key, similarityComparer)) / (double)g.Count());
+              }
+              fragmentFrequenciesTable.Rows[prefixString].Values.Add(fragment.Value.Value);
+            }
+          } else {
+            fragmentFrequenciesTable.Rows[prefixString].Values.Add(fragment.Value.Value);
+          }
+        }
+        foreach (var row in fragmentFrequenciesTable.Rows.Where(row => row.Values.Count == Generations.Value))
+          row.Values.Add(0.0);
+
+        #region Write fragment information to file
+
+        //        using (var streamWriter = new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "CommonFragments.txt"))) {
+        //          streamWriter.WriteLine("Median edge weight: " + medianWeight);
+        //          streamWriter.WriteLine("Average edge weight: " + averageWeight);
+        //          streamWriter.WriteLine("Symbol frequencies: ");
+        //          double sum = graph.Nodes.Sum(node => node.Weight);
+        //          foreach (var symbolNode in graph.Nodes.OrderBy(node => node.Weight)) {
+        //            streamWriter.WriteLine("{0}\t{1}", symbolNode.Label, String.Format("{0:0.00}", symbolNode.Weight / sum));
+        //          }
+        //          streamWriter.WriteLine();
+        //          streamWriter.WriteLine("Fragment root symbol frequencies:");
+        //          foreach (var group in fragments.GroupBy(x => x.Root.Symbol.Name)) {
+        //            streamWriter.WriteLine("{0}\t{1}", group.Key, String.Format("{0:0.00}", (double)group.Count() / NumberOfFragmentsToGenerate.Value));
+        //          }
+        //          streamWriter.WriteLine();
+        //          foreach (var fragment in mostCommonFragments) {
+        //            streamWriter.WriteLine(fragment.Key.ToPrefixString());
+        //            streamWriter.WriteLine("Frequency in last generation: {0}, Contained in best individual: {1}",
+        //              fragment.Value, trees[0].ContainsFragment(fragment.Key, SimilarityLevel.High) ? "YES" : "NO");
+        //            SymbolicExpressionTreeMatching.RenderNode(streamWriter, fragment.Key, string.Empty);
+        //            if (Results.ContainsKey(PopulationGraphParameterName)) {
+        //              var populationGraph = (SymbolicExpressionTreeGenealogyGraph)Results[PopulationGraphParameterName].Value;
+        //              streamWriter.Write("Frequencies per generation: ");
+        //              var groups = populationGraph.Nodes.GroupBy(n => n.Rank).OrderBy(g => g.Key);
+        //              var frequencies = (from g in groups.Where(g => g.Key == (int)g.Key)
+        //                                 let freq = g.Count(n => n.SymbolicExpressionTree.ContainsFragment(fragment.Key, SimilarityLevel.High))
+        //                                 select freq);
+        //              foreach (var freq in frequencies)
+        //                streamWriter.Write(freq / count + " ");
+        //              streamWriter.WriteLine();
+        //            } else {
+        //              streamWriter.WriteLine("Frequecy in current population: {0}", fragment.Value);
+        //            }
+        //            streamWriter.WriteLine("\n");
+        //          }
+        //          streamWriter.WriteLine("Average fragment length: {0}", avgFragmentLength);
+        //          streamWriter.WriteLine("Average fragment depth: {0}", avgFragmentDepth);
+        //          streamWriter.WriteLine("Percentage of unique generated fragments: {0}", distinctFragments.Count() / (double)fragments.Count);
+        //        }
+
+        #endregion
+      }
+      return base.Apply();
+    }
+
+    private IEnumerable<IFragment> GenerateFragments(SymbolGraph graph, ISymbolicExpressionTreeGrammar grammar, int numFragments, int maxDepth, int maxLength) {
+      var fragments = new List<IFragment>();
+      var random = RandomParameter.ActualValue;
+      var count = SymbolicExpressionTreeParameter.ActualValue.Count();
+      var threshold = count * FrequentFragmentOccurrenceThreshold.Value;
+      var availableSymbols = graph.Nodes.Where(x => x.OutEdges != null && x.OutEdges.Count > 0 && x.Weight >= threshold).ToList();
+      var weights = availableSymbols.Select(x => x.Weight).ToList();
+
+      if (!(availableSymbols.Count == 0 || weights.Count == 0))
+        for (int i = 0; i != numFragments; ++i) {
+          var symbol = availableSymbols.SelectRandom(weights, random);
+          var fragment = CreateFragment(symbol, random, grammar, threshold, maxDepth, maxLength, EnforceGrammarArity.Value);
+          fragments.Add(new Fragment { Root = fragment });
+        }
+      return fragments;
+    }
+
+    private static ISymbolicExpressionTreeNode CreateFragment(SymbolNode symbolNode, IRandom random, ISymbolicExpressionTreeGrammar grammar, double threshold, int depthLimit, int lengthLimit, bool enforceGrammarArity = true) {
+      var node = symbolNode.Symbol.CreateTreeNode();
+      if (node.HasLocalParameters) node.ResetLocalParameters(random);
+      if (node is VariableTreeNode) (node as VariableTreeNode).VariableName = symbolNode.Label;
+
+      if (symbolNode.OutEdges == null || symbolNode.OutEdges.Count == 0 || depthLimit < 0)
+        return node; // node is a leaf so we just return it
+
+      int maxCount = grammar.GetMaximumSubtreeCount(node.Symbol);
+      if (maxCount > 0) {
+        int minCount = grammar.GetMinimumSubtreeCount(node.Symbol);
+        var arity = random.Next(enforceGrammarArity ? minCount : 1, maxCount + 1);
+        var possibleChildConnections = new List<SymbolArc>();
+
+        if (depthLimit <= 2 || lengthLimit <= maxCount) { // if we are near the depth limit then we want to add leafs on the next level
+          possibleChildConnections.AddRange(from e in symbolNode.OutEdges
+                                            let n = (SymbolNode)e.Target
+                                            where grammar.GetMaximumSubtreeCount(n.Symbol) == 0
+                                            where n.Weight >= threshold
+                                            select e);
+        }
+        // if there are no available connections towards leaf nodes (in case depthLimit <= 2)
+        // or in case the depthLimit has not been reached yet
+        if (possibleChildConnections.Count == 0)
+          possibleChildConnections.AddRange(symbolNode.OutEdges.Where(a => ((SymbolNode)a.Target).Weight >= threshold)); // this will not be empty since we check above if the OutEdges are null
+        var weights = new double[possibleChildConnections.Count];
+
+        for (int i = 0; i != arity; ++i) {
+          // adjust weights according to the probability a child will find itself on a certain argument position
+          for (int j = 0; j != possibleChildConnections.Count; ++j) {
+            var childSymbolNode = (SymbolNode)possibleChildConnections[j].Target;
+            double sumPos = childSymbolNode.Positions.Sum(x => x.Value);
+            int v; childSymbolNode.Positions.TryGetValue(i, out v);
+            weights[j] = possibleChildConnections[j].Weight * v / sumPos;
+          }
+
+          if (weights.Sum().IsAlmost(0.0)) continue;
+
+          var selectedConnection = possibleChildConnections.SelectRandom(weights, random);
+          var selectedChildSymbolNode = selectedConnection.Target as SymbolNode;
+          var child = CreateFragment(selectedChildSymbolNode, random, grammar, threshold, depthLimit - 1, --lengthLimit);
+          if (child == null) throw new Exception("Child cannot be null.");
+          node.AddSubtree(child);
+        }
+      }
+      return node;
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreePopulationDiversityAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreePopulationDiversityAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreePopulationDiversityAnalyzer.cs	(revision 10265)
@@ -0,0 +1,231 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+
+// type definitions for ease of use
+using CloneMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItem>;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// Population diversity analyzer
+  /// </summary>
+  [Item("SymbolicExpressionTreePopulationDiversityAnalyzer", "An operator that tracks population diversity")]
+  [StorableClass]
+  public sealed class SymbolicExpressionTreePopulationDiversityAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    #region Parameter names
+    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string UpdateIntervalParameterName = "UpdateInterval";
+    private const string UpdateCounterParameterName = "UpdateCounter";
+    private const string ResultsParameterName = "Results";
+    private const string GenerationsParameterName = "Generations";
+    private const string StoreHistoryParameterName = "StoreHistory";
+    // comparer parameters
+    private const string MatchVariablesParameterName = "MatchVariableNames";
+    private const string MatchVariableWeightsParameterName = "MatchVariableWeights";
+    private const string MatchConstantValuesParameterName = "MatchConstantValues";
+    private const string SortSubtreesParameterName = "SortSubtrees";
+    private const string SimilarityValuesParmeterName = "Similarity";
+    // clone map
+    private const string GlobalCloneMapParameterName = "GlobalCloneMap";
+
+    #endregion
+
+    #region Parameters
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateIntervalParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public LookupParameter<IntValue> GenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
+    }
+    public ValueParameter<BoolValue> StoreHistoryParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[StoreHistoryParameterName]; }
+    }
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchVariableNamesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariablesParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchVariableWeightsParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariableWeightsParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchConstantValuesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchConstantValuesParameterName]; }
+    }
+    public ValueParameter<BoolValue> SortSubtreesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[SortSubtreesParameterName]; }
+    }
+    public LookupParameter<CloneMapType> GlobalCloneMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[GlobalCloneMapParameterName]; }
+    }
+    public ILookupParameter<DoubleValue> SimilarityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[SimilarityValuesParmeterName]; }
+    }
+    #endregion
+
+    #region Parameter properties
+    public IntValue MaximumSymbolicExpressionTreeDepth { get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; } }
+    public IntValue UpdateInterval { get { return UpdateIntervalParameter.Value; } }
+    public IntValue UpdateCounter { get { return UpdateCounterParameter.Value; } }
+    public ResultCollection Results { get { return ResultsParameter.ActualValue; } }
+    public CloneMapType GlobalCloneMap { get { return GlobalCloneMapParameter.ActualValue; } }
+    public IntValue Generations { get { return GenerationsParameter.ActualValue; } }
+    public BoolValue StoreHistory { get { return StoreHistoryParameter.Value; } }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicExpressionTreePopulationDiversityAnalyzer(bool deserializing)
+      : base(deserializing) {
+    }
+
+    private SymbolicExpressionTreePopulationDiversityAnalyzer(
+      SymbolicExpressionTreePopulationDiversityAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreePopulationDiversityAnalyzer(this, cloner);
+    }
+
+    public SymbolicExpressionTreePopulationDiversityAnalyzer() {
+      // add parameters
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariablesParameterName, "Specify if the symbolic expression tree comparer should match variable names.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariableWeightsParameterName, "Specify if the symbolic expression tree comparer should match variable weights.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchConstantValuesParameterName, "Specify if the symbolic expression tree comparer should match constant values.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>(SortSubtreesParameterName, "Specifies whether the subtrees of a tree should be sorted before comparison."));
+      Parameters.Add(new LookupParameter<CloneMapType>(GlobalCloneMapParameterName, "A global map keeping track of trees and their clones (made during selection)."));
+      Parameters.Add(new ValueParameter<BoolValue>(StoreHistoryParameterName, "True if the tree lengths history of the population should be stored.", new BoolValue(false)));
+      Parameters.Add(new LookupParameter<DoubleValue>(SimilarityValuesParmeterName, ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
+      UpdateCounterParameter.Hidden = true;
+      UpdateIntervalParameter.Hidden = true;
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(MaximumSymbolicExpressionTreeDepthParameterName)) {
+        Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
+      }
+    }
+
+    #region IStatefulItem members
+    public override void InitializeState() {
+      UpdateCounter.Value = 0;
+      base.InitializeState();
+    }
+    #endregion
+
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+
+    public override IOperation Apply() {
+      if (SimilarityParameter.ActualValue == null || SimilarityParameter.ActualValue.Value.IsAlmost(-1.0)) {
+        UpdateCounter.Value++;
+        if (UpdateCounter.Value != UpdateInterval.Value) return base.Apply();
+        UpdateCounter.Value = 0;
+        var trees = SymbolicExpressionTreeParameter.ActualValue.ToList();
+        if (SortSubtreesParameter.Value.Value) {
+          var canonicalSorter = new SymbolicExpressionTreeCanonicalSorter();
+          foreach (var t in trees) canonicalSorter.SortSubtrees(t);
+        }
+
+        SimilarityParameter.ActualValue = new DoubleValue();
+        // needed only with the old (and inefficient) geneticitem-based similarity measure
+        //        var geneticItems = trees.ToDictionary(tree => tree, tree => tree.GetGeneticItems(1, MaximumSymbolicExpressionTreeDepth.Value - 2).ToArray());
+
+        var comp = new SymbolicExpressionTreeNodeSimilarityComparer {
+          MatchConstantValues = MatchConstantValuesParameter.Value.Value,
+          MatchVariableNames = MatchVariableNamesParameter.Value.Value,
+          MatchVariableWeights = MatchVariableWeightsParameter.Value.Value
+        };
+
+        var operations = new OperationCollection { Parallel = true };
+        foreach (var tree in trees) {
+          var op = new SymbolicDataAnalysisExpressionTreeSimilarityCalculator { CurrentSymbolicExpressionTree = tree, SimilarityComparer = comp, MaximumTreeDepth = MaximumSymbolicExpressionTreeDepth.Value };
+          var operation = ExecutionContext.CreateChildOperation(op, ExecutionContext.Scope);
+          operations.Add(operation);
+        }
+        return new OperationCollection { operations, ExecutionContext.CreateOperation(this) };
+      }
+
+      ResultCollection results = ResultsParameter.ActualValue;
+      // population diversity
+      DataTable populationDiversityTable;
+      if (!results.ContainsKey("PopulationDiversity")) {
+        populationDiversityTable = new DataTable("PopulationDiversity") { VisualProperties = { YAxisTitle = "Diversity" } };
+        results.Add(new Result("PopulationDiversity", populationDiversityTable));
+      }
+      populationDiversityTable = (DataTable)results["PopulationDiversity"].Value;
+      if (!populationDiversityTable.Rows.ContainsKey("Diversity"))
+        populationDiversityTable.Rows.Add(new DataRow("Diversity") { VisualProperties = { StartIndexZero = true } });
+
+      int length = SymbolicExpressionTreeParameter.ActualValue.Length;
+      var similarity = SimilarityParameter.ActualValue.Value / (length * (length - 1) / 2.0);
+      var diversity = 1 - similarity;
+      SimilarityParameter.ActualValue.Value = -1.0;
+
+      populationDiversityTable.Rows["Diversity"].Values.Add(diversity);
+
+      // selection diversity
+      if (GlobalCloneMap == null) return base.Apply();
+      DataTable relativeSelectionCountsTable;
+      if (!results.ContainsKey("SelectedIndividuals")) {
+        relativeSelectionCountsTable = new DataTable("SelectedIndividuals") { VisualProperties = { YAxisTitle = "% Selected Individuals" } };
+        results.Add(new Result("SelectedIndividuals", relativeSelectionCountsTable));
+      }
+      relativeSelectionCountsTable = (DataTable)Results["SelectedIndividuals"].Value;
+      if (!relativeSelectionCountsTable.Rows.ContainsKey("SelectedIndividuals")) {
+        relativeSelectionCountsTable.Rows.Add(new DataRow("SelectedIndividuals") { VisualProperties = { StartIndexZero = true } });
+      }
+      double relativeSelectionCount = GlobalCloneMap.Values.Distinct().Count() / (double)SymbolicExpressionTreeParameter.ActualValue.Length;
+      relativeSelectionCountsTable.Rows["SelectedIndividuals"].Values.Add(relativeSelectionCount);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreePruningAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreePruningAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreePruningAnalyzer.cs	(revision 10265)
@@ -0,0 +1,213 @@
+﻿using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [Item("SymbolicExpressionTreePruningAnalyzer", "An analyzer that identifies introns in the population and optionally removes them.")]
+  [StorableClass]
+  public sealed class SymbolicExpressionTreePruningAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string SymbolicExpressionTreeQualityParameterName = "Quality";
+    private const string UpdateIntervalParameterName = "UpdateInterval";
+    private const string UpdateCounterParameterName = "UpdateCounter";
+    private const string MatchVariablesParameterName = "MatchVariableNames";
+    private const string MatchVariableWeightsParameterName = "MatchVariableWeights";
+    private const string MatchConstantValuesParameterName = "MatchConstantValues";
+    private const string ResultsParameterName = "Results";
+    private const string SymbolicExpressionInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
+    private const string SymbolicRegressionProblemDataParameterName = "ProblemData";
+    private const string FrequencyThresholdParameterName = "FrequencyThreshold";
+    private const string IgnoreSubtreeFrequenciesParameterName = "IgnoreFrequencies";
+
+    [Storable]
+    private SymbolicRegressionSolutionImpactValuesCalculator calculator;
+    [Storable]
+    private SymbolicExpressionTreeNodeSimilarityComparer comparer;
+
+    #region Parameters
+    public ValueParameter<IntValue> UpdateIntervalParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchVariableNamesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariablesParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchVariableWeightsParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchVariableWeightsParameterName]; }
+    }
+    public ValueParameter<BoolValue> MatchConstantValuesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[MatchConstantValuesParameterName]; }
+    }
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> SymbolicExpressionTreeQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[SymbolicExpressionTreeQualityParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public ILookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
+      get { return (ILookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicExpressionInterpreterParameterName]; }
+    }
+    public ILookupParameter<RegressionProblemData> SymbolicRegressionProblemDataParameter {
+      get { return (ILookupParameter<RegressionProblemData>)Parameters[SymbolicRegressionProblemDataParameterName]; }
+    }
+    public ValueParameter<DoubleValue> FrequencyThresholdParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters[FrequencyThresholdParameterName]; }
+    }
+    public ValueParameter<BoolValue> IgnoreSubtreeFrequenciesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[IgnoreSubtreeFrequenciesParameterName]; }
+    }
+    #endregion
+
+    #region Parameter properties
+    public bool MatchValues {
+      get { return MatchConstantValuesParameter.Value.Value; }
+    }
+    public bool MatchWeights {
+      get { return MatchVariableWeightsParameter.Value.Value; }
+    }
+    public bool MatchVariables {
+      get { return MatchVariableNamesParameter.Value.Value; }
+    }
+    public IntValue UpdateCounter {
+      get { return UpdateCounterParameter.Value; }
+    }
+    public IntValue UpdateInterval {
+      get { return UpdateIntervalParameter.Value; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public SymbolicDataAnalysisExpressionTreeInterpreter SymbolicExpressionTreeInterpreter {
+      get { return SymbolicExpressionTreeInterpreterParameter.ActualValue; }
+    }
+    public RegressionProblemData ProblemData {
+      get { return SymbolicRegressionProblemDataParameter.ActualValue; }
+    }
+    public DoubleValue FrequencyThreshold {
+      get { return FrequencyThresholdParameter.Value; }
+    }
+    public bool IgnoreSubtreesFrequencies {
+      get { return IgnoreSubtreeFrequenciesParameter.Value.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicExpressionTreePruningAnalyzer(bool deserializing) : base(deserializing) { }
+    private SymbolicExpressionTreePruningAnalyzer(SymbolicExpressionTreePruningAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      calculator = original.calculator;
+      comparer = original.comparer;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreePruningAnalyzer(this, cloner);
+    }
+
+    public SymbolicExpressionTreePruningAnalyzer() {
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(SymbolicExpressionTreeQualityParameterName, "The qualities of the symbolic expression trees"));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariablesParameterName, "Specify if the symbolic expression tree comparer should match variable names.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchVariableWeightsParameterName, "Specify if the symbolic expression tree comparer should match variable weights.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>(MatchConstantValuesParameterName, "Specify if the symbolic expression tree comparer should match constant values.", new BoolValue(true)));
+      Parameters.Add(new LookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicExpressionInterpreterParameterName, "Interpreter for symbolic expression trees"));
+      Parameters.Add(new LookupParameter<RegressionProblemData>(SymbolicRegressionProblemDataParameterName, "The symbolic data analysis problem."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new ValueParameter<DoubleValue>(FrequencyThresholdParameterName, "The frequency threshold a fragment has to exceed before being removed."));
+      Parameters.Add(new ValueParameter<BoolValue>(IgnoreSubtreeFrequenciesParameterName, "Specifies whether or not subtree frequencies should be taken into account."));
+
+      calculator = new SymbolicRegressionSolutionImpactValuesCalculator();
+      comparer = new SymbolicExpressionTreeNodeSimilarityComparer { MatchConstantValues = MatchValues, MatchVariableWeights = MatchWeights, MatchVariableNames = MatchVariables };
+
+      UpdateCounterParameter.Hidden = true;
+      UpdateIntervalParameter.Hidden = true;
+    }
+
+    public override IOperation Apply() {
+      UpdateCounter.Value++;
+      if (UpdateCounter.Value != UpdateInterval.Value) return base.Apply();
+      UpdateCounter.Value = 0;
+
+      //var prunedSubtrees = new IntValue(0);
+      int prunedNodes = 0;
+      int prunedTrees = 0;
+      DataTable prunedSubtreesTable;
+      if (Results.ContainsKey("Pruning")) {
+        prunedSubtreesTable = (DataTable)Results["Pruning"].Value;
+      } else {
+        prunedSubtreesTable = new DataTable("Pruning");
+        var prunedNodesRow = new DataRow("Pruned Nodes") { VisualProperties = { StartIndexZero = true } };
+        var prunedTreesRow = new DataRow("Pruned Trees") { VisualProperties = { StartIndexZero = true } };
+        prunedSubtreesTable.Rows.Add(prunedNodesRow);
+        prunedSubtreesTable.Rows.Add(prunedTreesRow);
+        Results.Add(new Result("Pruning", prunedSubtreesTable));
+      }
+
+      var trees = SymbolicExpressionTreeParameter.ActualValue.ToList();
+      var qualities = SymbolicExpressionTreeQualityParameter.ActualValue.ToList();
+      var prunedTreesMap = new bool[trees.Count];
+
+      for (int i = 0; i != trees.Count; ++i) {
+        var model = new SymbolicRegressionModel(trees[i], SymbolicExpressionTreeInterpreter);
+        var root = trees[i].Root.GetSubtree(0).GetSubtree(0); // skip the program root symbol and the start symbol
+        var nodes = root.IterateNodesPrefix().Select((node, index) => new { Node = node, Index = index }).ToList();
+        for (int j = 0; j < nodes.Count; ++j) {
+          var n = nodes[j];
+          if (n.Node is ConstantTreeNode) continue;
+          double impact = calculator.CalculateImpactValue(model, n.Node, ProblemData, ProblemData.TrainingIndices, qualities[i].Value);
+
+          //if (impact.IsAlmost(0.0)) {
+          if (impact < 0.001) {
+            bool prune = true;
+            if (!IgnoreSubtreesFrequencies) {
+              double frequency = (double)trees.Count(t => t.Root.ContainsFragment(new Fragment { Root = n.Node, Index = n.Index }, comparer)) / trees.Count;
+              // remove node if its frequency is above the threshold
+              if (frequency < FrequencyThreshold.Value) { prune = false; }
+            }
+            if (!prune) continue;
+            var parent = n.Node.Parent;
+            if (parent != null && !(parent.Symbol is StartSymbol)) {
+              double replacementValue = calculator.CalculateReplacementValue(model, n.Node, ProblemData, ProblemData.TrainingIndices);
+              var constantNode = new ConstantTreeNode(new Constant()) { Value = replacementValue };
+              var index = parent.IndexOfSubtree(n.Node);
+              parent.RemoveSubtree(index);
+              parent.InsertSubtree(index, constantNode);
+              // skip the removed subtree
+              int length = n.Node.GetLength();
+              j += length;
+
+              if (!prunedTreesMap[i]) {
+                prunedTrees++;
+                prunedTreesMap[i] = true;
+              }
+              prunedNodes += (length - 1);
+            }
+          }
+        }
+      }
+
+      prunedSubtreesTable.Rows["Pruned Nodes"].Values.Add(prunedNodes);
+      prunedSubtreesTable.Rows["Pruned Trees"].Values.Add(prunedTrees);
+
+      return base.Apply();
+    }
+
+    public bool EnabledByDefault { get { return true; } }
+
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeRelativeLengthAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeRelativeLengthAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeRelativeLengthAnalyzer.cs	(revision 10265)
@@ -0,0 +1,240 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.EvolutionaryTracking.Analyzers {
+  /// <summary>
+  /// An analyzer that adapts selection pressure based on average three length
+  /// </summary>
+  [Item("SymbolicExpressionTreeRelativeLengthAnalyzer", "An analyzer that adapts selection pressure based on average three length")]
+  [StorableClass]
+  class SymbolicExpressionTreeRelativeLengthAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    private const string UpdateIntervalParameterName = "UpdateInterval";
+    private const string UpdateCounterParameterName = "UpdateCounter";
+    private const string ResultsParameterName = "Results";
+    private const string GenerationsParameterName = "Generations";
+
+    private const string ExpectedAverageTreeLenghtParameterName = "ExpectedAverageTreeLength";
+    private const string RandomSelectionWindowSizeParameterName = "RandomSelectionWindowSize";
+    private const string RandomSelectionGenerationsCounterParameterName = "RandomSelectionGenerationsCounter";
+    private const string UpperBoundingFactorParameterName = "UpperBoundingFactor";
+    private const string LowerBoundingFactorParameterName = "LowerBoundingFactor";
+    private const string ActualTournamentGroupSizeParameterName = "TournamentGroupSize";
+
+    readonly MersenneTwister random = new MersenneTwister(12345);
+
+    #region Parameter properties
+    public ValueParameter<IntValue> UpdateIntervalParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public LookupParameter<IntValue> GenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
+    }
+    public ValueParameter<DoubleValue> ExpectedAverageTreeLengthParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters[ExpectedAverageTreeLenghtParameterName]; }
+    }
+    public ValueParameter<DoubleValue> UpperBoundingFactorParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters[UpperBoundingFactorParameterName]; }
+    }
+    public ValueParameter<DoubleValue> LowerBoundingFactorParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters[LowerBoundingFactorParameterName]; }
+    }
+    public ValueParameter<IntValue> RandomSelectionWindowSizeParameter {
+      get { return (ValueParameter<IntValue>)Parameters[RandomSelectionWindowSizeParameterName]; }
+    }
+    public ValueParameter<IntValue> RandomSelectionGenerationsCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[RandomSelectionGenerationsCounterParameterName]; }
+    }
+    public ValueParameter<IntValue> ActualTournamentGroupSizeParameter {
+      get { return (ValueParameter<IntValue>)Parameters[ActualTournamentGroupSizeParameterName]; }
+    }
+    #endregion
+
+    #region Parameters
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+    public IntValue UpdateInterval {
+      get { return UpdateIntervalParameter.Value; }
+    }
+    public IntValue UpdateCounter {
+      get { return UpdateCounterParameter.Value; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public IntValue Generations {
+      get { return GenerationsParameter.ActualValue; }
+    }
+    public DoubleValue ExpectedAverageTreeLength {
+      get { return (DoubleValue)ExpectedAverageTreeLengthParameter.ActualValue; }
+    }
+    public IntValue RandomSelectionWindowSize {
+      get { return (IntValue)RandomSelectionWindowSizeParameter.ActualValue; }
+    }
+    public IntValue RandomSelectionGenerationsCounter {
+      get { return (IntValue)RandomSelectionGenerationsCounterParameter.ActualValue; }
+    }
+    public IntValue ActualTournamentGroupSize {
+      get { return (IntValue)ActualTournamentGroupSizeParameter.ActualValue; }
+      set { ActualTournamentGroupSizeParameter.ActualValue = value; }
+    }
+    public DoubleValue LowerBoundingFactor {
+      get { return (DoubleValue)LowerBoundingFactorParameter.ActualValue; }
+    }
+    public DoubleValue UpperBoundingFactor {
+      get { return (DoubleValue)UpperBoundingFactorParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected SymbolicExpressionTreeRelativeLengthAnalyzer(bool deserializing)
+      : base() {
+    }
+    protected SymbolicExpressionTreeRelativeLengthAnalyzer(SymbolicExpressionTreeRelativeLengthAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreeRelativeLengthAnalyzer(this, cloner);
+    }
+    public SymbolicExpressionTreeRelativeLengthAnalyzer()
+      : base() {
+      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
+      Parameters.Add(new ValueParameter<DoubleValue>(ExpectedAverageTreeLenghtParameterName, "The expected statistical average of the tree length for given grammar and depth and random trees", new DoubleValue(0)));
+      Parameters.Add(new ValueParameter<DoubleValue>(UpperBoundingFactorParameterName, "Multiplier for the expected average size, giving the upper bound of the average size length", new DoubleValue(3.0)));
+      Parameters.Add(new ValueParameter<DoubleValue>(LowerBoundingFactorParameterName, "Multiplier for the expected average size, giving the lower bound of the average size length", new DoubleValue(2.0)));
+      Parameters.Add(new ValueParameter<IntValue>(RandomSelectionWindowSizeParameterName, "Maximum window for random selection (in generations)"));
+      Parameters.Add(new ValueParameter<IntValue>(RandomSelectionGenerationsCounterParameterName, "Counter for the consecutive random selection generations"));
+      Parameters.Add(new ValueParameter<IntValue>(ActualTournamentGroupSizeParameterName, "Parameter to store the actual tournament size so we can reuse it later.", new IntValue(0)));
+
+      UpdateCounterParameter.Hidden = true;
+      UpdateIntervalParameter.Hidden = true;
+    }
+    #region After deserialization code
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // check if all the parameters are present and accounted for 
+      if (!Parameters.ContainsKey(UpdateIntervalParameterName)) {
+        Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      }
+      if (!Parameters.ContainsKey(UpdateCounterParameterName)) {
+        Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+        UpdateCounterParameter.Hidden = true;
+      }
+    }
+    #endregion
+    #region IStatefulItem members
+    public override void InitializeState() {
+      base.InitializeState();
+      UpdateCounter.Value = 0;
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+      UpdateCounter.Value = 0;
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      UpdateCounter.Value++;
+      if (UpdateCounter.Value == UpdateInterval.Value) {
+        UpdateCounter.Value = 0;
+
+        var gaContext = ExecutionContext.Parent.Parent;
+        var selectorParameter = gaContext.Parameters["Selector"];
+        var selector = selectorParameter.ActualValue as TournamentSelector;
+        var gScope = ExecutionContext.Scope;
+        while (gScope.Parent != null) gScope = gScope.Parent;
+
+        if (Generations.Value == 0) {
+          UpdateCounter.Value = 0; // reset the update counter
+          if (ActualTournamentGroupSize.Value == 0)
+            ActualTournamentGroupSize = new IntValue(selector.GroupSizeParameter.Value.Value);
+          else
+            selector.GroupSizeParameter.Value = ActualTournamentGroupSize;
+
+          // check the threshhold value by simulating the average tree length using the GrowTreeCreator
+          var randomTrees = new List<ISymbolicExpressionTree>();
+
+          var problemContext = gaContext.Parent;
+
+          var grammar = (ISymbolicExpressionGrammar)problemContext.Parameters["SymbolicExpressionTreeGrammar"].ActualValue;
+          var maxDepth = (IntValue)problemContext.Parameters["MaximumSymbolicExpressionTreeDepth"].ActualValue;
+
+          long length = 0;
+          const uint size = 1000;
+          for (int i = 0; i != size; ++i) {
+            randomTrees.Add(GrowTreeCreator.Create(random, grammar, 0, maxDepth.Value));
+            length += randomTrees.Last().Length;
+          }
+          ExpectedAverageTreeLength.Value = (double)length / size;
+
+          return base.Apply();
+        } else if (Generations.Value >= 10) {
+          // this should provide a bloat control mechanism while allowing population diversity to increase
+          double currentAverageTreeLength = (from s in gScope.SubScopes
+                                             let tree = s.Variables.First().Value as ISymbolicExpressionTree
+                                             select tree.Length).Average();
+
+          double expectedAverage = ExpectedAverageTreeLength.Value;
+
+          if (currentAverageTreeLength >= UpperBoundingFactor.Value * expectedAverage) {
+            SetGroupSize(selector, 1);
+          }
+          if (RandomSelectionGenerationsCounter.Value == RandomSelectionWindowSize.Value ||
+              currentAverageTreeLength <= LowerBoundingFactor.Value * expectedAverage) {
+
+            SetGroupSize(selector, ActualTournamentGroupSize.Value);
+            RandomSelectionGenerationsCounter.Value = 0;
+          } else {
+            RandomSelectionGenerationsCounter.Value++;
+          }
+        }
+      }
+      return base.Apply();
+    }
+
+    void SetGroupSize(TournamentSelector ts, int value) {
+      ts.GroupSizeParameter.Value = new IntValue(value);
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeShapeAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeShapeAnalyzer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/SymbolicExpressionTreeShapeAnalyzer.cs	(revision 10265)
@@ -0,0 +1,149 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// An operator that gathers information on tree fragments that get passed from one generation to the next via genetic operators
+  /// (Tracking of genetic variance and heredity)
+  /// </summary>
+  [Item("SymbolicExpressionTreeFragmentsAnalyzer", "An operator that provides statistics about crossover fragments")]
+  [StorableClass]
+  public sealed class SymbolicExpressionTreeShapeAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    #region Parameter names
+    private const string UpdateIntervalParameterName = "UpdateInterval";
+    private const string UpdateCounterParameterName = "UpdateCounter";
+    private const string ResultsParameterName = "Results";
+    private const string GenerationsParameterName = "Generations";
+    #endregion
+
+    #region Parameter properties
+    public ValueParameter<IntValue> UpdateIntervalParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter {
+      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public LookupParameter<IntValue> GenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
+    }
+    #endregion
+
+    #region Parameters
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+    public IntValue UpdateInterval {
+      get { return UpdateIntervalParameter.Value; }
+    }
+    public IntValue UpdateCounter {
+      get { return UpdateCounterParameter.Value; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public IntValue Generations {
+      get { return GenerationsParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicExpressionTreeShapeAnalyzer(bool deserializing) : base(deserializing) { }
+
+    private SymbolicExpressionTreeShapeAnalyzer(SymbolicExpressionTreeShapeAnalyzer original, Cloner cloner) : base(original, cloner) { }
+
+    private SymbolicExpressionTreeShapeAnalyzer()
+      : base() {
+      #region Add parameters
+      // analyzer update counter and update interval
+      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
+      #endregion
+
+      UpdateCounterParameter.Hidden = true;
+      UpdateIntervalParameter.Hidden = true;
+
+    }
+    #region After deserialization code
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // check if all the parameters are present and accounted for 
+      if (!Parameters.ContainsKey(UpdateIntervalParameterName)) {
+        Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
+      }
+      if (!Parameters.ContainsKey(UpdateCounterParameterName)) {
+        Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
+        UpdateCounterParameter.Hidden = true;
+      }
+    }
+    #endregion
+    #region IStatefulItem members
+    public override void InitializeState() {
+      base.InitializeState();
+      UpdateCounter.Value = 0;
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+      UpdateCounter.Value = 0;
+    }
+    #endregion
+
+    public override IOperation Apply() {
+
+      return base.Apply();
+    }
+
+    private static int VisitationLength(ISymbolicExpressionTree tree) {
+      return VisitationLength(tree.Root);
+    }
+
+    private static int PathLength(ISymbolicExpressionTree tree) {
+      return PathLength(tree.Root);
+    }
+
+    private static int VisitationLength(ISymbolicExpressionTreeNode node) {
+      return node.IterateNodesBreadth().Sum(n => n.GetLength());
+    }
+
+    private static int PathLength(ISymbolicExpressionTreeNode node) {
+      return node.IterateNodesBreadth().Sum(n => node.GetBranchLevel(n)) + 1;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreeShapeAnalyzer(this, cloner);
+    }
+  } //SymbolicExpressionTreeFragmentsAnalyzer
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/FPGraph.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/FPGraph.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/FPGraph.cs	(revision 10265)
@@ -0,0 +1,62 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [Item("Symbol graph", "A graph used to store the relationship between symbols in a population of individuals")]
+  [StorableClass]
+  public class FPGraph : GenericGraph<SymbolNode> {
+    [Storable]
+    public Dictionary<int, List<SymbolNode>> Levels { get { return levels; } }
+    private Dictionary<int, List<SymbolNode>> levels = new Dictionary<int, List<SymbolNode>>();
+
+    public void AddNode(SymbolNode node, int level) {
+      if (levels.ContainsKey(level)) {
+        SymbolNode match = levels[level].Find(n => n.Label.Equals(node.Label));
+        if (match == null) {
+          levels[level].Add(node);
+        }
+      } else {
+        levels[level] = new List<SymbolNode> { node };
+      }
+      base.AddNode(node);
+    }
+
+    public bool ContainsKey(string key, int level) {
+      return levels.ContainsKey(level) && levels[level].Select(n => n.Label).Contains(key);
+    }
+
+    public SymbolNode GetNode(string key, int level) {
+      SymbolNode node = null;
+      if (levels.ContainsKey(level))
+        node = levels[level].Find(n => n.Label.Equals(key));
+      return node;
+    }
+
+    void AddArc(SymbolNode source, SymbolNode target, double weight, object data = null) {
+      source.AddForwardArc(target, weight, data);
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenericGraph/Arc.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenericGraph/Arc.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenericGraph/Arc.cs	(revision 10265)
@@ -0,0 +1,45 @@
+﻿using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// An arc that can have a weight, a label, and can old additional information in the Data object
+  /// </summary>
+  [StorableClass]
+  public class Arc : Item, IEdge {
+    [Storable]
+    private IVertex source;
+    public IVertex Source { get { return source; } set { source = value; } }
+    [Storable]
+    private IVertex target;
+    public IVertex Target { get { return target; } set { target = value; } }
+    [Storable]
+    private string label;
+    public string Label { get { return label; } set { label = value; } }
+    [Storable]
+    private double weight;
+    public double Weight { get { return weight; } set { weight = value; } }
+    [Storable]
+    private object data;
+    public object Data { get { return data; } set { data = value; } }
+
+    [StorableConstructor]
+    public Arc(bool deserializing) : base(deserializing) { }
+
+    public Arc() { }
+
+    private Arc(Arc original, Cloner cloner)
+      : base(original, cloner) {
+      Source = original.Source;
+      Target = original.Target;
+      Label = original.Label;
+      Weight = original.Weight;
+      Data = original.Data;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Arc(this, cloner);
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenericGraph/GenericGraph.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenericGraph/GenericGraph.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenericGraph/GenericGraph.cs	(revision 10265)
@@ -0,0 +1,102 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [Item("Directed graph", "Generic directed graph base class.")]
+  [StorableClass]
+  public class GenericGraph<T> : Item, IGenericGraph<T> where T : class, IVertex {
+    [Storable]
+    private readonly List<T> nodes; // graph will consist of a set of nodes of type T
+    public List<T> Nodes {
+      get { return nodes; }
+    }
+
+    public GenericGraph() {
+      nodes = new List<T>();
+    }
+
+    public GenericGraph(IGenericGraph<T> g) {
+      nodes = new List<T>(g.Nodes);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GenericGraph<T>(this, cloner);
+    }
+
+    public override Image ItemImage {
+      get { return Common.Resources.VSImageLibrary.Graph; }
+    }
+
+    [StorableConstructor]
+    protected GenericGraph(bool serializing)
+      : base(serializing) {
+    }
+
+    protected GenericGraph(GenericGraph<T> original, Cloner cloner)
+      : base(original, cloner) {
+      nodes = new List<T>(original.Nodes); // bburlacu: maybe the list should be empty
+    }
+
+    public virtual bool Contains(T t) {
+      return nodes.Contains(t);
+    }
+
+    public virtual bool IsEmpty {
+      get { return !nodes.Any(); }
+    }
+
+    public virtual bool Any(Func<T, bool> predicate) {
+      return nodes.Any(predicate);
+    }
+
+    public virtual void Clear() {
+      nodes.Clear();
+    }
+
+    /// <summary>
+    /// Adds a node representing an individual
+    /// </summary>
+    /// <param name="node">The node to add</param>
+    public virtual void AddNode(T node) {
+      Nodes.Add(node);
+    }
+
+    /// <summary>
+    /// Remove a node from the graph along with edges associated with it
+    /// </summary>
+    /// <param name="t">The graph node</param>
+    public virtual void RemoveNode(T t) {
+      Nodes.Remove(t);
+    }
+
+    public double AverageDegree {
+      get { return Nodes.Average(x => x.Degree); }
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenericGraph/Vertex.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenericGraph/Vertex.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenericGraph/Vertex.cs	(revision 10265)
@@ -0,0 +1,163 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [StorableClass]
+  public class Vertex : Item, IVertex {
+    [Storable]
+    private string id;
+    public string Id { get { return id; } }
+    [Storable]
+    private string label;
+    public string Label { get { return label; } set { label = value; } }
+    [Storable]
+    private double weight;
+    public double Weight { get { return weight; } set { weight = value; } }
+    [Storable]
+    private List<IEdge> inEdges;
+    public List<IEdge> InEdges { get { return inEdges; } private set { inEdges = value; } }
+    [Storable]
+    private List<IEdge> outEdges;
+    public List<IEdge> OutEdges { get { return outEdges; } private set { outEdges = value; } }
+    [Storable]
+    private object content;
+    public object Content {
+      get { return content; }
+      set {
+        if (value == null)
+          throw new ArgumentException("Node content cannot be null.");
+        content = value;
+      }
+    }
+
+    [StorableConstructor]
+    public Vertex(bool deserializing) : base(deserializing) { }
+
+    public Vertex() {
+      id = Guid.NewGuid().ToString();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (id == null) {
+        id = Guid.NewGuid().ToString();
+      }
+    }
+
+    protected Vertex(Vertex original, Cloner cloner)
+      : base(original, cloner) {
+      Content = original.Content;
+      id = Guid.NewGuid().ToString();
+      Label = original.Label;
+      Content = original.Content;
+      InEdges = new List<IEdge>(original.InEdges);
+      OutEdges = new List<IEdge>(original.OutEdges);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Vertex(this, cloner);
+    }
+
+    public Vertex(Vertex node) {
+      id = Guid.NewGuid().ToString();
+      Label = node.Label;
+      Content = node.Content;
+      InEdges = new List<IEdge>(node.InEdges);
+      OutEdges = new List<IEdge>(node.OutEdges);
+    }
+
+    public int InDegree { get { return InEdges == null ? 0 : InEdges.Count; } }
+    public int OutDegree { get { return OutEdges == null ? 0 : OutEdges.Count; } }
+    public int Degree { get { return InDegree + OutDegree; } }
+
+    /// <summary>
+    /// Performs an upward-breath-traversal of the graph using the nodes InEdges
+    /// </summary>
+    /// <returns>All the ancestors of the current node</returns>
+    public IEnumerable<IVertex> Ancestors() {
+      // for performance, we use a hashset for lookup and a list for iteration
+      var nodes = new HashSet<IVertex> { this };
+      var list = new List<IVertex> { this };
+      int i = 0;
+      while (i != list.Count) {
+        if (list[i].InEdges != null) {
+          foreach (var e in list[i].InEdges) {
+            if (nodes.Contains(e.Source)) continue;
+            nodes.Add(e.Source);
+            list.Add(e.Source);
+          }
+        }
+        ++i;
+      }
+      return list;
+    }
+
+    /// <summary>
+    /// Performs a downward-breath-traversal of the genealogy graph using the nodes OutEdges
+    /// </summary>
+    /// <returns>All the descendants of the current node</returns>
+    public IEnumerable<IVertex> Descendants() {
+      var nodes = new HashSet<IVertex> { this };
+      var list = new List<IVertex> { this };
+      int i = 0;
+      while (i != list.Count) {
+        if (list[i].OutEdges != null) {
+          foreach (var e in list[i].OutEdges) {
+            if (nodes.Contains(e.Target)) continue;
+            nodes.Add(e.Target);
+            list.Add(e.Target);
+          }
+        }
+        ++i;
+      }
+      return list;
+    }
+    // this method can be used to add arcs towards targets that are not visible in the graph 
+    // (they do not appear in the nodes Dictionary). It is the programmers responsibility to 
+    // enforce the correct and desired behavior.
+    public void AddForwardArc(IVertex target, double weight = 0.0, object data = null) {
+      var e = new Arc { Source = this, Target = target, Data = data, Weight = weight };
+      if (OutEdges == null) OutEdges = new List<IEdge> { e };
+      else OutEdges.Add(e);
+    }
+    public void AddForwardArc(IEdge arc) {
+      if (arc.Source == null) { arc.Source = this; }
+      if (arc.Source != this) { throw new Exception("AddForwardArc: Source should be equal to this."); }
+      if (OutEdges == null) { OutEdges = new List<IEdge> { arc }; } else { OutEdges.Add(arc); }
+    }
+    public void AddReverseArc(IEdge arc) {
+      if (arc.Target == null) { arc.Target = this; }
+      if (arc.Target != this) { throw new Exception("AddReverseArc: Target should be equal to this."); };
+      if (InEdges == null) { InEdges = new List<IEdge> { arc }; } else { InEdges.Add(arc); }
+    }
+    public void AddReverseArc(IVertex source, double weight = 0.0, object data = null) {
+      var e = new Arc { Source = source, Target = this, Data = data, Weight = weight };
+      if (InEdges == null) InEdges = new List<IEdge> { e };
+      else InEdges.Add(e);
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj	(revision 10265)
@@ -0,0 +1,180 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.EvolutionaryTracking</RootNamespace>
+    <AssemblyName>HeuristicLab.EvolutionaryTracking-3.4</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.Analysis-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Analyzers\BuildingBlocks\RelevantBuildingBlocksAnalyzer.cs" />
+    <Compile Include="Analyzers\BuildingBlocks\Poly10BuildingBlocksAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreePruningAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreeShapeAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreeEvolvabilityAnalyzer.cs" />
+    <Compile Include="Analyzers\Fragments\SymbolicExpressionTreeRelativeFragmentDepthAnalyzer.cs" />
+    <Compile Include="Analyzers\Fragments\SymbolicExpressionTreeFragmentLengthsAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreeFrequentPatternsAnalyzer.cs" />
+    <Compile Include="Analyzers\Fragments\SymbolicExpressionTreeFragmentsAnalyzer.cs" />
+    <Compile Include="FPGraph.cs" />
+    <Compile Include="Interfaces\IEdge.cs" />
+    <Compile Include="LineageExplorer.cs" />
+    <Compile Include="Operators\LineageAggregator.cs" />
+    <Compile Include="Operators\SymbolicExpressionTreeFPBuilder.cs" />
+    <Compile Include="Operators\SymbolicExpressionTreeGenealogyGraphBuilder.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreePopulationDiversityAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreeRelativeLengthAnalyzer.cs" />
+    <Compile Include="GenericGraph\GenericGraph.cs" />
+    <Compile Include="GenericGraph\Arc.cs" />
+    <Compile Include="GenericGraph\Vertex.cs" />
+    <Compile Include="Interfaces\IGenericGraph.cs" />
+    <Compile Include="Interfaces\IVertex.cs" />
+    <Compile Include="Interfaces\ISymbolicExpressionTreeGenealogyGraph.cs" />
+    <Compile Include="Operators\CleanupOperator.cs" />
+    <Compile Include="Operators\SymbolicExpressionTreeSymbolGraphBuilder.cs" />
+    <Compile Include="Operators\Util.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SymbolGraph.cs" />
+    <Compile Include="SymbolicExpressionTreeGenealogyGraph\SymbolicExpressionTreeGenealogyGraph.cs" />
+    <Compile Include="SymbolicExpressionTreeGenealogyGraph\SymbolicExpressionTreeGenealogyGraphNode.cs" />
+  </ItemGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <WCFMetadata Include="Service References\" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj.user
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj.user	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj.user	(revision 10265)
@@ -0,0 +1,6 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectView>ProjectFiles</ProjectView>
+  </PropertyGroup>
+</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/IEdge.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/IEdge.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/IEdge.cs	(revision 10265)
@@ -0,0 +1,6 @@
+﻿namespace HeuristicLab.EvolutionaryTracking {
+  public interface IEdge {
+    IVertex Source { get; set; }
+    IVertex Target { get; set; }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/IGenericGraph.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/IGenericGraph.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/IGenericGraph.cs	(revision 10265)
@@ -0,0 +1,35 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  public interface IGenericGraph<T> : IItem where T : class, IVertex {
+    bool Contains(T t); // graph contains specific node?
+    bool Any(Func<T, bool> predicate); // graph contains any nodes matching the given predicate?
+    void Clear(); // clear graph
+    void AddNode(T nodeData);
+    void RemoveNode(T t); // remove node if contained in the graph
+    List<T> Nodes { get; }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/ISymbolicExpressionTreeGenealogyGraph.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/ISymbolicExpressionTreeGenealogyGraph.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/ISymbolicExpressionTreeGenealogyGraph.cs	(revision 10265)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  public interface ISymbolicExpressionTreeGenealogyGraph : IGenericGraph<SymbolicExpressionTreeGenealogyGraphNode> {
+    List<SymbolicExpressionTreeGenealogyGraphNode> GetGraphNodes(ISymbolicExpressionTree tree);
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/IVertex.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/IVertex.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Interfaces/IVertex.cs	(revision 10265)
@@ -0,0 +1,46 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  public interface IVertex {
+    string Id { get; }
+    List<IEdge> InEdges { get; }
+    List<IEdge> OutEdges { get; }
+
+
+    int InDegree { get; }
+    int OutDegree { get; }
+    int Degree { get; }
+
+    string Label { get; set; }
+    double Weight { get; set; }
+
+    IEnumerable<IVertex> Ancestors();
+    IEnumerable<IVertex> Descendants();
+
+    void AddForwardArc(IVertex target, double weight = 0.0, object content = null);
+    void AddForwardArc(IEdge arc);
+    void AddReverseArc(IVertex target, double weight = 0.0, object content = null);
+    void AddReverseArc(IEdge arc);
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/LineageExplorer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/LineageExplorer.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/LineageExplorer.cs	(revision 10265)
@@ -0,0 +1,31 @@
+﻿using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [StorableClass]
+  public class LineageExplorer : Item {
+    [Storable]
+    private ISymbolicExpressionTreeGenealogyGraph genealogyGraph;
+    public ISymbolicExpressionTreeGenealogyGraph GenealogyGraph { get { return genealogyGraph; } set { genealogyGraph = value; } }
+    [Storable]
+    private IList<Tuple<ISymbolicExpressionTree, double>> trees;
+    public IList<Tuple<ISymbolicExpressionTree, double>> Trees { get { return trees; } set { trees = value; } }
+    [Storable]
+    private int generations;
+    public int Generations { get { return generations; } set { generations = value; } }
+
+    private LineageExplorer(bool deserializing) : base(deserializing) { }
+    private LineageExplorer(LineageExplorer original, Cloner cloner)
+      : base(original, cloner) {
+      genealogyGraph = original.genealogyGraph;
+      trees = original.trees;
+      generations = original.generations;
+    }
+    public LineageExplorer() { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new LineageExplorer(this, cloner); }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/CleanupOperator.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/CleanupOperator.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/CleanupOperator.cs	(revision 10265)
@@ -0,0 +1,175 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using CloneMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItem>;
+using GeneticExchangeMapType = HeuristicLab.Core.ItemList<HeuristicLab.Core.IItem>;
+using TraceMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItemList<HeuristicLab.Core.IItem>>;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// An operator which performs some cleanup at the end of the main loop.
+  /// </summary>
+  [Item("CleanupOperator", "This operator should be the last to run in the main loop and clean up the tracking-related data structures.")]
+  [StorableClass]
+  public sealed class CleanupOperator : SingleSuccessorOperator {
+    #region Parameter Names
+    private const string GlobalTraceMapParameterName = "GlobalTraceMap";
+    private const string GlobalCloneMapParameterName = "GlobalCloneMap";
+    private const string GlobalFragmentMapParameterName = "GlobalFragmentMap";
+    private const string GlobalGeneticExchangeMapParameterName = "GlobalGeneticExchangeMap";
+    private const string PopulationGraphParameterName = "PopulationGraph";
+    private const string GenerationsParameterName = "Generations";
+    private const string MaximumGenerationsParameterName = "MaximumGenerations";
+    private const string ResultsParameterName = "Results";
+    private const string CleanGenealogyGraphParameterName = "CleanGenealogyGraph";
+    private const string UpdateGenealogyGraphParameterName = "UpdateGenealogyGraph";
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string SymbolicExpressionTreeQualityParameterName = "Quality";
+    #endregion
+
+    #region Parameter Properties
+    public LookupParameter<TraceMapType> GlobalTraceMapParameter {
+      get { return (LookupParameter<TraceMapType>)Parameters[GlobalTraceMapParameterName]; }
+    }
+    public LookupParameter<CloneMapType> GlobalCloneMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[GlobalCloneMapParameterName]; }
+    }
+    public LookupParameter<CloneMapType> GlobalFragmentMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[GlobalFragmentMapParameterName]; }
+    }
+    public LookupParameter<GeneticExchangeMapType> GlobalGeneticExchangeMapParameter {
+      get { return (LookupParameter<GeneticExchangeMapType>)Parameters[GlobalGeneticExchangeMapParameterName]; }
+    }
+    public LookupParameter<IntValue> GenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
+    }
+    public LookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[MaximumGenerationsParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public ValueParameter<BoolValue> CleanGenealogyGraphParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[CleanGenealogyGraphParameterName]; }
+    }
+    public ValueParameter<BoolValue> UpdateGenealogyGraphParameter {
+      get { return (ValueParameter<BoolValue>)Parameters[UpdateGenealogyGraphParameterName]; }
+    }
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> SymbolicExpressionTreeQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[SymbolicExpressionTreeQualityParameterName]; }
+    }
+    #endregion
+
+    #region Properties
+    private CloneMapType GlobalCloneMap { get { return GlobalCloneMapParameter.ActualValue; } }
+    private TraceMapType GlobalTraceMap { get { return GlobalTraceMapParameter.ActualValue; } }
+    private CloneMapType GlobalFragmentMap { get { return GlobalFragmentMapParameter.ActualValue; } }
+    private GeneticExchangeMapType GlobalGeneticExchangeMap { get { return GlobalGeneticExchangeMapParameter.ActualValue; } }
+    private IntValue Generations { get { return GenerationsParameter.ActualValue; } }
+    private IntValue MaximumGenerations { get { return MaximumGenerationsParameter.ActualValue; } }
+    private ResultCollection Results { get { return ResultsParameter.ActualValue; } }
+    public BoolValue CleanGenealogyGraph { get { return CleanGenealogyGraphParameter.Value; } }
+    public BoolValue UpdateGenealogyGraph { get { return UpdateGenealogyGraphParameter.Value; } }
+    private IEnumerable<DoubleValue> Quality { get { return SymbolicExpressionTreeQualityParameter.ActualValue; } }
+    private IEnumerable<ISymbolicExpressionTree> SymbolicExpressionTree { get { return SymbolicExpressionTreeParameter.ActualValue; } }
+    #endregion
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(GlobalGeneticExchangeMapParameterName))
+        Parameters.Add(new LookupParameter<GeneticExchangeMapType>(GlobalGeneticExchangeMapParameterName));
+      if (!Parameters.ContainsKey(CleanGenealogyGraphParameterName))
+        Parameters.Add(new ValueParameter<BoolValue>(CleanGenealogyGraphParameterName));
+      if (!Parameters.ContainsKey(UpdateGenealogyGraphParameterName))
+        Parameters.Add(new ValueParameter<BoolValue>(UpdateGenealogyGraphParameterName));
+      if (!Parameters.ContainsKey(SymbolicExpressionTreeParameterName))
+        Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
+      if (!Parameters.ContainsKey(SymbolicExpressionTreeQualityParameterName))
+        Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(SymbolicExpressionTreeQualityParameterName, "The qualities of the symbolic expression trees"));
+    }
+
+    [StorableConstructor]
+    private CleanupOperator(bool deserializing) : base(deserializing) { }
+    private CleanupOperator(SingleSuccessorOperator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new CleanupOperator(this, cloner); }
+
+    public CleanupOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<TraceMapType>(GlobalTraceMapParameterName));
+      Parameters.Add(new LookupParameter<CloneMapType>(GlobalCloneMapParameterName));
+      Parameters.Add(new LookupParameter<CloneMapType>(GlobalFragmentMapParameterName));
+      Parameters.Add(new LookupParameter<GeneticExchangeMapType>(GlobalGeneticExchangeMapParameterName));
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName));
+      Parameters.Add(new LookupParameter<IntValue>(MaximumGenerationsParameterName));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new ValueParameter<BoolValue>(CleanGenealogyGraphParameterName));
+      Parameters.Add(new ValueParameter<BoolValue>(UpdateGenealogyGraphParameterName));
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(SymbolicExpressionTreeQualityParameterName, "The qualities of the symbolic expression trees"));
+    }
+
+    public override IOperation Apply() {
+      if (GlobalCloneMap != null) GlobalCloneMap.Clear();
+      if (GlobalFragmentMap != null) GlobalFragmentMap.Clear();
+      if (GlobalTraceMap != null) GlobalTraceMap.Clear();
+      if (GlobalGeneticExchangeMap != null) GlobalGeneticExchangeMap.Clear();
+
+      if (!Results.ContainsKey(PopulationGraphParameterName)) return base.Apply();
+      var graph = (SymbolicExpressionTreeGenealogyGraph)Results[PopulationGraphParameterName].Value;
+      if (graph == null) return base.Apply();
+
+      if (UpdateGenealogyGraph.Value) {
+        // update vertex qualities if the trees in the scope were optimized by the ConstantOptimizationAnalyzer
+        ISymbolicExpressionTree[] trees = SymbolicExpressionTree.ToArray();
+        double[] qualities = Quality.Select(x => x.Value).ToArray();
+
+        for (int i = 0; i != trees.Length; ++i) {
+          foreach (var graphNode in graph.GetGraphNodes(trees[i])) {
+            graphNode.Quality = qualities[i];
+          }
+        }
+      }
+
+      // if we are at the end of the run, then we clear the genealogy graph (to save memory)
+      if (CleanGenealogyGraph.Value) {
+        if (Generations.Value == MaximumGenerations.Value)
+          if (Results.ContainsKey(PopulationGraphParameterName)) {
+            Results.Remove(PopulationGraphParameterName);
+            graph.Dispose();
+          }
+      }
+      return base.Apply();
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/LineageAggregator.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/LineageAggregator.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/LineageAggregator.cs	(revision 10265)
@@ -0,0 +1,101 @@
+﻿using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// This operator basically aggregates together a scope list of trees in the current generation and the genealogy graph so far
+  /// in a new object that can be used as Content for the InteractiveIndividualHistoryView
+  /// </summary>
+  [StorableClass]
+  public class GenealogyAggregator : SingleSuccessorOperator {
+    private const string PopulationGraphParameterName = "PopulationGraph";
+    private const string LineageExplorerParameterName = "LineageExplorer";
+    private const string ResultsParameterName = "Results";
+    private const string GenerationsParameterName = "Generations";
+    private const string MaximumGenerationsParameterName = "MaximumGenerations";
+
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string SymbolicExpressionTreeQualityParameterName = "Quality";
+
+    #region Parameter properties
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> SymbolicExpressionTreeQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[SymbolicExpressionTreeQualityParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public LookupParameter<IntValue> GenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
+    }
+    public LookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[MaximumGenerationsParameterName]; }
+    }
+    #endregion
+    #region Properties
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public IntValue Generations {
+      get { return GenerationsParameter.ActualValue; }
+    }
+    public IntValue MaximumGenerations {
+      get { return MaximumGenerationsParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() { }
+
+    #region IStatefulItem members
+    public override void InitializeState() {
+      base.InitializeState();
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+    }
+    #endregion
+
+    [StorableConstructor]
+    private GenealogyAggregator(bool deserializing) : base(deserializing) { }
+    private GenealogyAggregator(GenealogyAggregator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new GenealogyAggregator(this, cloner); }
+    public GenealogyAggregator() {
+      #region Add parameters
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
+      Parameters.Add(new LookupParameter<IntValue>(MaximumGenerationsParameterName, "The maximum number of generations"));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(SymbolicExpressionTreeQualityParameterName, "The qualities of the symbolic expression trees"));
+      #endregion
+    }
+
+    public override IOperation Apply() {
+      if (!Results.ContainsKey(PopulationGraphParameterName)) return base.Apply();
+      var graph = (SymbolicExpressionTreeGenealogyGraph)Results[PopulationGraphParameterName].Value;
+      var trees = SymbolicExpressionTreeParameter.ActualValue;
+      var qualities = SymbolicExpressionTreeQualityParameter.ActualValue;
+      var tuples = trees.Zip(qualities, (t, q) => new Tuple<ISymbolicExpressionTree, double>(t, q.Value)).ToList();
+      var lineageExplorer = new LineageExplorer { GenealogyGraph = graph, Trees = tuples, Generations = Generations.Value };
+      if (!Results.ContainsKey(LineageExplorerParameterName))
+        Results.Add(new Result(LineageExplorerParameterName, lineageExplorer));
+      else Results[LineageExplorerParameterName].Value = lineageExplorer;
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/SymbolicExpressionTreeFPBuilder.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/SymbolicExpressionTreeFPBuilder.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/SymbolicExpressionTreeFPBuilder.cs	(revision 10265)
@@ -0,0 +1,221 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// Operator which builds a so-called frequenct pattern tree
+  /// (a compact representation of the symbol relationships in the population)
+  /// </summary>
+  [Item("SymbolicExpressionTreeFPBuilder", "Builds a frequent-pattern tree out of the GP population.")]
+  [StorableClass]
+  public class SymbolicExpressionTreeFPBuilder : SingleSuccessorOperator {
+    private const string ResultsParameterName = "Results";
+    private const string SymbolicExpressionInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
+    private const string SymbolicRegressionProblemDataParameterName = "ProblemData";
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string SymbolicExpressionTreeQualityParameterName = "Quality";
+
+    private SymbolicRegressionSolutionImpactValuesCalculator calculator;
+    //    private Dictionary<SymbolNode, double> averageNodeImpacts;
+
+    #region Parameter properties
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> SymbolicExpressionTreeQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[SymbolicExpressionTreeQualityParameterName]; }
+    }
+    public ILookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
+      get { return (ILookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicExpressionInterpreterParameterName]; }
+    }
+    public ILookupParameter<RegressionProblemData> SymbolicRegressionProblemDataParameter {
+      get { return (ILookupParameter<RegressionProblemData>)Parameters[SymbolicRegressionProblemDataParameterName]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicExpressionTreeFPBuilder(bool deserializing)
+      : base(deserializing) {
+    }
+
+    private SymbolicExpressionTreeFPBuilder(SymbolicExpressionTreeFPBuilder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreeFPBuilder(this, cloner);
+    }
+
+    public SymbolicExpressionTreeFPBuilder()
+      : base() {
+      #region Add parameters
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new LookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicExpressionInterpreterParameterName, "Interpreter for symbolic expression trees"));
+      Parameters.Add(new LookupParameter<RegressionProblemData>(SymbolicRegressionProblemDataParameterName, "The symbolic data analysis problem."));
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(SymbolicExpressionTreeQualityParameterName, "The qualities of the symbolic expression trees"));
+      #endregion
+
+      calculator = new SymbolicRegressionSolutionImpactValuesCalculator();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+    }
+
+    #region IStatefulItem members
+
+    public override void InitializeState() {
+      base.InitializeState();
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+    }
+
+    #endregion
+
+    public override IOperation Apply() {
+      var trees = SymbolicExpressionTreeParameter.ActualValue;
+      var qualities = SymbolicExpressionTreeQualityParameter.ActualValue;
+
+      if (trees == null || qualities == null) return base.Apply();
+
+      if (trees.Length != qualities.Length)
+        throw new Exception("Error: trees and qualities array sizes do not match!");
+
+      var graph = new FPGraph();
+      var canonicalSorter = new SymbolicExpressionTreeCanonicalSorter();
+
+      var nodeImpacts = new Dictionary<SymbolNode, IList<double>>();
+      var impactsCalculator = new SymbolicRegressionSolutionImpactValuesCalculator();
+
+      for (int i = 0; i != trees.Length; ++i) {
+        var model = new SymbolicRegressionModel(trees[i], SymbolicExpressionTreeInterpreterParameter.ActualValue);
+
+        var root = trees[i].Root;
+        var originalQuality = qualities[i].Value;
+
+        foreach (var node in root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix())
+          MergeNodesAndImpacts(graph, model, node, originalQuality, nodeImpacts, impactsCalculator, 0);
+      }
+
+      WriteGraphAndImpacts(graph, nodeImpacts, Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\fpgraph.dot", 0.0);
+      WriteGraphAndImpacts(graph, nodeImpacts, Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\prunedfpgraph.dot", 0.1);
+      return base.Apply();
+    }
+
+    private void MergeNodesAndImpacts(FPGraph graph, ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node,
+                                      double originalQuality, IDictionary<SymbolNode, IList<double>> nodeImpacts,
+                                      ISymbolicDataAnalysisSolutionImpactValuesCalculator impactValuesCalculator, int level = 0) {
+      var label = node.Label();
+      var symbolNode = graph.GetNode(label, level);
+      if (symbolNode == null) {
+        symbolNode = new SymbolNode { Label = label, Symbol = node.Symbol, Weight = 1 };
+        graph.AddNode(symbolNode, level);
+      } else {
+        symbolNode.Weight += 1;
+      }
+      var problemData = SymbolicRegressionProblemDataParameter.ActualValue;
+
+      var impact = impactValuesCalculator.CalculateImpactValue(model, node, problemData, problemData.TrainingIndices, originalQuality);
+      if (nodeImpacts.ContainsKey(symbolNode)) {
+        nodeImpacts[symbolNode].Add(impact);
+      } else {
+        nodeImpacts.Add(symbolNode, new List<double> { impact });
+      }
+      foreach (var s in node.Subtrees) {
+        MergeNodesAndImpacts(graph, model, s, originalQuality, nodeImpacts, impactValuesCalculator, level + 1);
+
+        var childLabel = s.Label();
+        var childSymbolNode = graph.GetNode(childLabel, level + 1);
+        if (childSymbolNode == null)
+          throw new ArgumentException("SymbolNode cannot be null!");
+
+        if (symbolNode.OutEdges == null || symbolNode.OutEdges.Count == 0)
+          symbolNode.AddForwardArc(childSymbolNode);
+        else {
+          var arc = symbolNode.OutEdges.Find(e => e.Target == childSymbolNode);
+          if (arc == null)
+            symbolNode.AddForwardArc(childSymbolNode);
+          else arc.Weight += 1;
+        }
+      }
+    }
+
+    private static void WriteGraphAndImpacts(FPGraph graph, IDictionary<SymbolNode, IList<double>> nodeImpacts, string path, double pruneFactor = 0.1) {
+      var nl = Environment.NewLine;
+      const string shape = "rectangle";
+
+      var avgImpacts = nodeImpacts.ToDictionary(n => n.Key, n => n.Value.Average());
+
+      double max = avgImpacts.Values.Max();
+      double min = avgImpacts.Values.Min();
+
+      long total = (long)graph.Nodes.Sum(node => node.Weight);
+
+      var tuples = (from l in graph.Levels.ToList()
+                    let sum = l.Value.Sum(n => n.Weight)
+                    from node in l.Value
+                    where node.Weight / sum > pruneFactor
+                    select new Tuple<SymbolNode, int, double>(node, l.Key, node.Weight / sum)
+                   ).ToList();
+
+      using (var file = new StreamWriter(path)) {
+        var sb = new StringBuilder();
+        file.WriteLine("digraph {");
+
+        var hashset = new HashSet<SymbolNode>(tuples.Select(t => t.Item1));
+        foreach (var tuple in tuples) {
+          var node = tuple.Item1;
+          var level = tuple.Item2;
+          node.Label = node.Label + ":" + level;
+          var relativeWeight = tuple.Item3;
+          var impact = avgImpacts[node];
+          if (double.IsInfinity(impact)) {
+            throw new ArgumentOutOfRangeException("Impact value cannot be infinite!");
+          }
+          Color color;
+          if (impact.IsAlmost(0.0)) {
+            color = Color.White;
+          } else if (impact < 0.0) {
+            color = Color.FromArgb((int)(impact / min * 255), Color.Red);
+          } else {
+            color = Color.FromArgb((int)(impact / max * 255), Color.Green);
+          }
+          file.WriteLine("\t\"" + node.Label + "\" [shape=" + shape + ", style=filled, fillcolor=\"" + color.ToHex() + "\""
+                         + ", label=\"" + node.Label + "\\n" + string.Format("{0:0.00%}", node.Weight / total)
+                         + "\\n" + string.Format("{0:0.00%}", relativeWeight) + "\", rank=same]");
+        }
+        foreach (var node in tuples.Select(t => t.Item1)) {
+          if (node.OutEdges == null || node.OutEdges.Count == 0) continue;
+          foreach (var arc in node.OutEdges) {
+            if (!hashset.Contains(arc.Target)) continue;
+            //            double relativeWeight = arc.Weight / node.OutEdges.Sum(a => a.Weight);
+            sb.Clear();
+            sb.Append("\t\"" + node.Label + "\" -> \"" + arc.Target.Label + "\""
+              //                        + "[label=\"" + string.Format("{0:0.00%}", relativeWeight) + "\"]"
+                      );
+            file.WriteLine(sb);
+          }
+        }
+        file.WriteLine("}");
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/SymbolicExpressionTreeGenealogyGraphBuilder.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/SymbolicExpressionTreeGenealogyGraphBuilder.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/SymbolicExpressionTreeGenealogyGraphBuilder.cs	(revision 10265)
@@ -0,0 +1,313 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+// type definitions for ease of use
+using CloneMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItem>;
+using TraceMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItemList<HeuristicLab.Core.IItem>>;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  /// <summary>
+  /// Builds a genealogy graph of the algorithms population.
+  /// </summary>
+  [Item("SymbolicExpressionTreeGenealogyGraphBuilder", "An operator that tracks the genealogy of tree individuals")]
+  [StorableClass]
+  public sealed class SymbolicExpressionTreeGenealogyGraphBuilder : SingleSuccessorOperator {
+    #region Parameter names
+    private const string ResultsParameterName = "Results";
+    private const string ElitesParameterName = "Elites";
+    private const string GenerationsParameterName = "Generations";
+    private const string MaximumGenerationsParameterName = "MaximumGenerations";
+    private const string MaximumSelectionPressureParameterName = "MaximumSelectionPressure";
+    private const string SelectionPressureParameterName = "SelectionPressure";
+    private const string GlobalTraceMapParameterName = "GlobalTraceMap";
+    private const string GlobalCloneMapParameterName = "GlobalCloneMap";
+    private const string GlobalFragmentMapParameterName = "GlobalFragmentMap";
+    private const string PopulationGraphParameterName = "PopulationGraph";
+    private const string PopulationGraphParameterDescription = "Individual lineages";
+    private const string SymbolicExpressionInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
+    private const string SymbolicRegressionProblemDataParameterName = "ProblemData";
+    private const string SymbolicDataAnalysisProblemEvaluatorParameterName = "Evaluator";
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string SymbolicExpressionTreeQualityParameterName = "Quality";
+    #endregion
+    #region Parameters
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> SymbolicExpressionTreeQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[SymbolicExpressionTreeQualityParameterName]; }
+    }
+    public LookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public LookupParameter<IntValue> ElitesParameter {
+      get { return (LookupParameter<IntValue>)Parameters[ElitesParameterName]; }
+    }
+    public LookupParameter<IntValue> GenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
+    }
+    public LookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters[MaximumGenerationsParameterName]; }
+    }
+    public LookupParameter<DoubleValue> SelectionPressureParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters[SelectionPressureParameterName]; }
+    }
+    public LookupParameter<DoubleValue> MaximumSelectionPressureParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters[MaximumSelectionPressureParameterName]; }
+    }
+    // problem data, interpreter and evaluator
+    public LookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter> SymbolicExpressionInterpreterParameter {
+      get { return (LookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicExpressionInterpreterParameterName]; }
+    }
+    public LookupParameter<RegressionProblemData> SymbolicRegressionProblemDataParameter {
+      get { return (LookupParameter<RegressionProblemData>)Parameters[SymbolicRegressionProblemDataParameterName]; }
+    }
+    public LookupParameter<IEvaluator> SymbolicDataAnalysisProblemEvaluatorParameter {
+      get { return (LookupParameter<IEvaluator>)Parameters[SymbolicDataAnalysisProblemEvaluatorParameterName]; }
+    }
+    // genealogy global parameters
+    public LookupParameter<TraceMapType> GlobalTraceMapParameter {
+      get { return (LookupParameter<TraceMapType>)Parameters[GlobalTraceMapParameterName]; }
+    }
+    public LookupParameter<CloneMapType> GlobalCloneMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[GlobalCloneMapParameterName]; }
+    }
+    public LookupParameter<CloneMapType> GlobalFragmentMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[GlobalFragmentMapParameterName]; }
+    }
+    #endregion
+    #region Parameter properties
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public IntValue Elites {
+      get { return ElitesParameter.ActualValue; }
+    }
+    public IntValue Generations {
+      get { return GenerationsParameter.ActualValue; }
+    }
+    public IntValue MaximumGenerations {
+      get { return MaximumGenerationsParameter.ActualValue; }
+    }
+    public DoubleValue SelectionPressure {
+      get { return SelectionPressureParameter.ActualValue; }
+    }
+    public DoubleValue MaximumSelectionPressure {
+      get { return MaximumSelectionPressureParameter.ActualValue; }
+    }
+    public CloneMapType GlobalCloneMap {
+      get { return GlobalCloneMapParameter.ActualValue; }
+    }
+    public TraceMapType GlobalTraceMap {
+      get { return GlobalTraceMapParameter.ActualValue; }
+    }
+    public CloneMapType GlobalFragmentMap {
+      get { return GlobalFragmentMapParameter.ActualValue; }
+    }
+    public SymbolicDataAnalysisExpressionTreeInterpreter SymbolicExpressionInterpreter {
+      get { return SymbolicExpressionInterpreterParameter.ActualValue; }
+    }
+    public RegressionProblemData SymbolicRegressionProblemData {
+      get { return SymbolicRegressionProblemDataParameter.ActualValue; }
+    }
+    public IEvaluator SymbolicDataAnalysisEvaluator {
+      get { return SymbolicDataAnalysisProblemEvaluatorParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicExpressionTreeGenealogyGraphBuilder(bool deserializing) : base(deserializing) { }
+    private SymbolicExpressionTreeGenealogyGraphBuilder(SymbolicExpressionTreeGenealogyGraphBuilder original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new SymbolicExpressionTreeGenealogyGraphBuilder(this, cloner); }
+    public SymbolicExpressionTreeGenealogyGraphBuilder()
+      : base() {
+      #region Add parameters
+      Parameters.Add(new LookupParameter<IntValue>(ElitesParameterName, "The number of elites."));
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
+      Parameters.Add(new LookupParameter<IntValue>(MaximumGenerationsParameterName, "The maximum number of generations"));
+      Parameters.Add(new LookupParameter<DoubleValue>(SelectionPressureParameterName, "The current selection (ony for OSGA)"));
+      Parameters.Add(new LookupParameter<DoubleValue>(MaximumSelectionPressureParameterName, "Maximum allowed value of selection pressure."));
+      Parameters.Add(new LookupParameter<TraceMapType>(GlobalTraceMapParameterName, "A global cache containing the whole genealogy."));
+      Parameters.Add(new LookupParameter<CloneMapType>(GlobalCloneMapParameterName, "A global map keeping track of trees and their clones (made during selection)."));
+      Parameters.Add(new LookupParameter<CloneMapType>(GlobalFragmentMapParameterName, "A global map keeping track of tree fragments received via crossover."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      Parameters.Add(new LookupParameter<SymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicExpressionInterpreterParameterName, "Interpreter for symbolic expression trees"));
+      Parameters.Add(new LookupParameter<RegressionProblemData>(SymbolicRegressionProblemDataParameterName, "The symbolic data analysis problem."));
+      Parameters.Add(new LookupParameter<IEvaluator>(SymbolicDataAnalysisProblemEvaluatorParameterName, "The fitness evaluator"));
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(SymbolicExpressionTreeQualityParameterName, "The qualities of the symbolic expression trees"));
+      #endregion
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() { }
+
+    #region IStatefulItem members
+    public override void InitializeState() {
+      base.InitializeState();
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+    }
+    #endregion
+
+    public override IOperation Apply() {
+      if (!Parameters.ContainsKey("Results")) return base.Apply();
+
+      SymbolicExpressionTreeGenealogyGraph graph;
+      if (Results.ContainsKey(PopulationGraphParameterName)) {
+        graph = (SymbolicExpressionTreeGenealogyGraph)(Results[PopulationGraphParameterName].Value);
+      } else {
+        graph = new SymbolicExpressionTreeGenealogyGraph();
+        Results.Add(new Result(PopulationGraphParameterName, PopulationGraphParameterDescription, graph));
+      }
+
+      var trees = SymbolicExpressionTreeParameter.ActualValue.ToArray();
+      var qualities = SymbolicExpressionTreeQualityParameter.ActualValue.ToArray();
+
+      if (trees.Length != qualities.Length)
+        throw new Exception("Error: trees and qualities array sizes do not match!");
+
+      // add all individuals to the evolutionary graph
+      int generation = Generations.Value;
+
+      var pairs = trees.Zip(qualities, (t, q) => new { Tree = t, Quality = q.Value }).OrderByDescending(x => x.Quality).ToList();
+
+      if (generation == 0) {
+        // add the trees in the graph and return
+        foreach (var pair in pairs) {
+          var tree = pair.Tree;
+          var quality = pair.Quality;
+          graph.AddNode(new SymbolicExpressionTreeGenealogyGraphNode {
+            SymbolicExpressionTree = tree,
+            Quality = quality,
+            Rank = generation
+          });
+        }
+        return base.Apply();
+      }
+
+      var graphNodes = (from i in Enumerable.Range(0, trees.Length)
+                        let tree = pairs[i].Tree
+                        let quality = pairs[i].Quality
+                        select new SymbolicExpressionTreeGenealogyGraphNode {
+                          SymbolicExpressionTree = tree,
+                          Quality = quality,
+                          Rank = generation,
+                          IsElite = i < Elites.Value
+                        }).Concat
+        // the following query addds the intermediate nodes that were created when 
+        // crossover was followed by mutation (they are not present in the scope) 
+        (from t in trees
+         where GlobalTraceMap.ContainsKey(t)
+         let parents = GlobalTraceMap[t]
+         where parents.Count == 1
+         // 1 parent means mutation
+         let p = (ISymbolicExpressionTree)parents[0]
+         select new SymbolicExpressionTreeGenealogyGraphNode {
+           SymbolicExpressionTree = p,
+           Quality = Evaluate(p),
+           Rank = generation - 0.5
+           // an intermediate parent that would normally be 'invisible' to the evolutionary process
+         }
+        ).ToList();
+
+      foreach (var node in graphNodes) {
+        graph.AddNode(node);
+      }
+
+      graphNodes.Sort((a, b) => b.Rank.CompareTo(a.Rank));
+
+      foreach (var node in graphNodes) {
+        var tree = node.SymbolicExpressionTree;
+        if (!GlobalTraceMap.ContainsKey(tree)) {
+          var nodes = graph.GetGraphNodes(tree);
+          if (nodes.Count > 1) {
+            // link elites from previous generation
+            var last = nodes[nodes.Count - 2];
+            var arc = new Arc { Source = last, Target = node, Data = new Fragment { Root = null } };
+            last.AddForwardArc(arc);
+            node.AddReverseArc(arc);
+          }
+          continue;
+        }
+
+        var parents = GlobalTraceMap[tree].Cast<ISymbolicExpressionTree>().ToList();
+        var fragment = GlobalFragmentMap[tree];
+        foreach (var p in parents) {
+          var nodes = graph.GetGraphNodes(p);
+          if (nodes == null) {
+            throw new Exception("Node cannot have no parents");
+          }
+          var sourceNode = nodes.LastOrDefault(n => n.Rank < node.Rank);
+          if (sourceNode == null) {
+            throw new Exception("Source node cannot be null");
+          }
+          var arc = new Arc { Source = sourceNode, Target = node, Data = fragment };
+          sourceNode.AddForwardArc(arc);
+          node.AddReverseArc(arc);
+        }
+        // the root parent is the one that receives the subtree/fragment from the other parent
+        // so it does not actually pass a subtree to the child, therefore the fragment is null
+        // so in case of crossover, we add a null fragment below
+        if (parents.Count > 1) node.InEdges[0].Data = new Fragment { Root = null };
+      }
+
+      // notify listeners that the genealogy graph was updated
+      graph.Updated();
+
+      return base.Apply();
+    }
+
+    /// <summary>
+    /// Evaluate a symbolic expression tree. We perform evaluation by adding a temporary subscope with the tree in it, and calling evaluator.Apply()
+    /// </summary>
+    /// <param name="tree">The symbolic expression tree to evaluate</param>
+    /// <returns>A double value representing the individual quality</returns>
+    private double Evaluate(IItem tree) {
+      var subScope = new Scope();
+      subScope.Variables.Add(new Core.Variable("SymbolicExpressionTree", tree)); // inject expected variables into the subscope
+      ExecutionContext.Scope.SubScopes.Add(subScope);
+      var context = new Core.ExecutionContext(ExecutionContext, SymbolicDataAnalysisEvaluator, subScope);
+      SymbolicDataAnalysisEvaluator.Execute(context, new CancellationToken()); // call evaluator.Apply()
+      double quality = ((DoubleValue)subScope.Variables["Quality"].Value).Value; // get the quality
+      ExecutionContext.Scope.SubScopes.Remove(subScope); // remove the subscope
+      return quality;
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/SymbolicExpressionTreeSymbolGraphBuilder.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/SymbolicExpressionTreeSymbolGraphBuilder.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/SymbolicExpressionTreeSymbolGraphBuilder.cs	(revision 10265)
@@ -0,0 +1,236 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+
+using GeneticExchangeMapType = HeuristicLab.Core.IItemList<HeuristicLab.Core.IItem>;
+
+namespace HeuristicLab.EvolutionaryTracking.Operators {
+  [Item("SymbolicExpressionTreeSymbolGraphBuilder", "An operator that builds a graph of pair-wise symbol relationships from the trees in the population.")]
+  [StorableClass]
+  class SymbolicExpressionTreeSymbolGraphBuilder : SingleSuccessorOperator {
+    #region Parameter names
+    private const string GlobalGeneticExchangeMapParameterName = "GlobalGeneticExchangeMap";
+    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
+    private const string ResultsParameterName = "Results";
+    #endregion
+    #region Parameter properties
+    public ILookupParameter<GeneticExchangeMapType> GlobalGeneticExchangeMapParameter {
+      get { return (LookupParameter<GeneticExchangeMapType>)Parameters[GlobalGeneticExchangeMapParameterName]; }
+    }
+    #endregion
+    #region Properties
+    public GeneticExchangeMapType GlobalGeneticExchangeMap {
+      get { return GlobalGeneticExchangeMapParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicExpressionTreeSymbolGraphBuilder(bool deserializing) : base(deserializing) { }
+    private SymbolicExpressionTreeSymbolGraphBuilder(SymbolicExpressionTreeSymbolGraphBuilder original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new SymbolicExpressionTreeSymbolGraphBuilder(this, cloner); }
+    public SymbolicExpressionTreeSymbolGraphBuilder() {
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
+      Parameters.Add(new LookupParameter<GeneticExchangeMapType>(GlobalGeneticExchangeMapParameterName, "Global map of genetic exchanges."));
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+    }
+    #region Parameters
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    #endregion
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ResultsParameterName))
+        Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
+      if (!Parameters.ContainsKey(GlobalGeneticExchangeMapParameterName))
+        Parameters.Add(new LookupParameter<GeneticExchangeMapType>(GlobalGeneticExchangeMapParameterName, "Global map of genetic exchanges."));
+    }
+    public override IOperation Apply() {
+      if (!Parameters.ContainsKey("Results")) return base.Apply();
+
+      var trees = SymbolicExpressionTreeParameter.ActualValue.ToList();
+
+      var results = ResultsParameter.ActualValue;
+
+      //      if (!results.ContainsKey("SymbolGraph")) {
+      //        var graph = CreateSymbolGraph(trees);
+      //        results.Add(new Result("SymbolGraph", graph));
+      //      } else {
+      //        var graph = results["SymbolGraph"].Value as SymbolGraph;
+      //        var transactions = GlobalGeneticExchangeMap.Select(t => t as GeneticExchange);
+      //        UpdateGraph(graph, transactions);
+      //      }
+
+      var graph = CreateSymbolGraph(trees);
+      if (!results.ContainsKey("SymbolGraph")) {
+        results.Add(new Result("SymbolGraph", graph));
+      } else {
+        results["SymbolGraph"].Value = graph;
+      }
+
+      return base.Apply();
+    }
+    private SymbolGraph CreateSymbolGraph(IEnumerable<ISymbolicExpressionTree> trees) {
+      var list = trees as IList<ISymbolicExpressionTree> ?? trees.ToList();
+
+      var nodes = list.SelectMany(x => x.Root.GetSubtree(0).GetSubtree(0).IterateNodesBreadth()).ToList();
+      var graph = new SymbolGraph();
+
+      #region create symbol graph
+      foreach (var node in nodes) {
+        var nodeLabel = node.Label();
+        if (!graph.ContainsKey(nodeLabel)) {
+          graph.AddNode(new SymbolNode { Label = nodeLabel, Symbol = node.Symbol, Weight = 1.0, AverageArity = node.SubtreeCount });
+        } else {
+          double avgArity = graph.GetNode(nodeLabel).AverageArity;
+          double weight = graph.GetNode(nodeLabel).Weight;
+          graph.GetNode(nodeLabel).AverageArity = (avgArity * weight + node.SubtreeCount) / (weight + 1);
+          graph.GetNode(nodeLabel).Weight += 1.0;
+        }
+      }
+
+      foreach (var node in nodes) {
+        var n = graph.GetNode(node.Symbol.Name);
+        for (int i = 0; i != node.SubtreeCount; ++i) {
+          var child = node.GetSubtree(i);
+          var c = graph.GetNode(child.Label());
+
+          if (n == null || c == null)
+            throw new Exception("The node couldn't be found in the graph."); // should never happen
+
+          if (n.OutEdges == null) {
+            n.AddForwardArc(c, 1.0);
+          } else {
+            var arc = n.OutEdges.Find(x => x.Target == c);
+            if (arc == null) n.AddForwardArc(c, 1);
+            else arc.Weight += 1.0;
+          }
+          if (c.Positions == null) {
+            c.Positions = new Dictionary<int, int> { { i, 1 } };
+          } else if (c.Positions.ContainsKey(i)) {
+            c.Positions[i] += 1;
+          } else {
+            c.Positions.Add(i, 1);
+          }
+        }
+      }
+      #endregion
+
+      return graph;
+    }
+
+    private static void UpdateGraph(SymbolGraph graph, IEnumerable<GeneticExchange> exchanges) {
+      // we have the graph, and we have the list of genetic exchanges which allows us to update graph vertex and arc weights
+      exchanges = exchanges as IList<GeneticExchange> ?? exchanges.ToList();
+      var inFragments = exchanges.Select(t => t.FragmentIn).ToList();
+      var outFragments = exchanges.Select(t => t.FragmentOut).ToList();
+
+      // the idea is to add to the symbol graph everything that goes in (inFragments) and
+      // subtract everything that goes out (outFragments)
+
+      // might not be 100% correct because the trees change as well
+
+      foreach (var f in inFragments) {
+        foreach (var node in f.Root.IterateNodesPrefix()) {
+          var parentLabel = node.Label();
+          var parentVertex = graph.GetNode(parentLabel);
+          if (parentVertex == null) { // highly unlikely but it is possible
+            graph.AddNode(new SymbolNode { Label = parentLabel, Symbol = node.Symbol, Weight = 1.0, AverageArity = node.SubtreeCount });
+            parentVertex = graph.GetNode(parentLabel);
+          } else {
+            parentVertex.Weight++;
+          }
+
+          for (int i = 0; i != node.SubtreeCount; ++i) {
+            var child = node.GetSubtree(i);
+            var childLabel = child.Label();
+            var childVertex = graph.GetNode(childLabel);
+
+            if (childVertex == null) { // highly unlikely but it is possible
+              graph.AddNode(new SymbolNode { Label = childLabel, Symbol = child.Symbol, Weight = 1.0, AverageArity = node.SubtreeCount });
+              childVertex = graph.GetNode(childLabel);
+            }
+
+            if (parentVertex.OutEdges == null)
+              parentVertex.AddForwardArc(childVertex, 1.0);
+            else {
+              var arc = parentVertex.OutEdges.Find(x => x.Target == childVertex);
+              if (arc == null) childVertex.AddForwardArc(childVertex, 1.0);
+              else arc.Weight += 1.0;
+            }
+
+            if (childVertex.Positions == null) {
+              childVertex.Positions = new Dictionary<int, int> { { i, 1 } };
+            } else if (childVertex.Positions.ContainsKey(i)) {
+              childVertex.Positions[i] += 1;
+            } else {
+              childVertex.Positions.Add(i, 1);
+            }
+          }
+        }
+      }
+
+      foreach (var f in outFragments) {
+        foreach (var node in f.Root.IterateNodesPrefix()) {
+          var parentLabel = node.Label();
+          var parentVertex = graph.GetNode(parentLabel);
+          if (parentVertex == null)
+            throw new ArgumentException("parentVertex for node in outFragment can (should) not be null!");
+
+          parentVertex.Weight--;
+
+          for (int i = 0; i != node.SubtreeCount; ++i) {
+            var child = node.GetSubtree(i);
+            var childVertex = graph.GetNode(child.Label());
+            if (childVertex == null)
+              throw new ArgumentException("childVertex for node in outFragment can (should) not be null!");
+
+            //            childVertex.Weight--;
+
+            var arc = parentVertex.OutEdges.Find(x => x.Target == childVertex);
+            if (arc == null)
+              throw new Exception("An arc should already exist between the parent and the child.");
+
+            arc.Weight -= 1.0;
+
+            if (arc.Weight < 0.0)
+              throw new ArgumentException("Weight cannot be negative!");
+          }
+        }
+      }
+    }
+
+    private static void NormalizeGraph(SymbolGraph graph) {
+      var nodes = graph.Nodes;
+      var sum = nodes.Sum(n => n.Weight);
+      foreach (var n in nodes) {
+        n.Weight /= sum;
+        if (n.OutEdges == null || n.OutEdges.Count <= 0) continue;
+        var arcSum = n.OutEdges.Sum(arc => arc.Weight);
+        foreach (var arc in n.OutEdges)
+          arc.Weight /= arcSum;
+      }
+    }
+    private static void PruneGraph(SymbolGraph graph) {
+      var arcs = graph.Nodes.Where(node => node.OutEdges != null).SelectMany(node => node.OutEdges).ToList();
+      var arcWeights = arcs.Select(arc => arc.Weight).ToList();
+      var median = arcWeights.Median();
+      foreach (var node in graph.Nodes.Where(n => n.OutEdges != null)) {
+        node.OutEdges.RemoveAll(arc => arc.Weight < median || ((SymbolNode)arc.Target).Symbol is Constant);
+        node.OutEdges.RemoveAll(arc => arc.Weight < median);
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/Util.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/Util.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/Util.cs	(revision 10265)
@@ -0,0 +1,167 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+
+namespace HeuristicLab.EvolutionaryTracking {
+
+  internal static class Util {
+    public static string Label(this ISymbolicExpressionTreeNode node) {
+      var v = node as VariableTreeNode;
+      return v == null ? node.Symbol.Name : v.VariableName;
+    }
+
+    public static string ToPrefixString(this ISymbolicExpressionTreeNode node) {
+      if (node.SubtreeCount == 0) return node.Label() + " ";
+      var sb = new StringBuilder();
+
+      sb.Append(node.Label().Substring(0, 3) + " ( ");
+      foreach (var s in node.Subtrees) {
+        sb.Append(s.ToPrefixString());
+      }
+      sb.Append(") ");
+      return sb.ToString();
+    }
+
+    public static void WriteDot(this IGenericGraph<SymbolNode> graph, string path) {
+      const double minNorm = 1.0, maxNorm = 3.0;
+
+      var arcs = graph.Nodes.Where(node => node.OutEdges != null).SelectMany(node => node.OutEdges).ToList();
+      double totalArcWeight = arcs.Sum(arc => arc.Weight);
+      double totalNodeWeight = graph.Nodes.Sum(node => node.Weight);
+      var min = arcs.Min(x => x.Weight);
+      var max = arcs.Max(x => x.Weight);
+
+      var normalizedWeights = arcs.Select(arc => new KeyValuePair<SymbolArc, double>(arc, (arc.Weight - min) * (maxNorm - minNorm) / (max - min) + minNorm))
+                                  .ToDictionary(x => x.Key, x => x.Value);
+
+      using (var file = new StreamWriter(path)) {
+        const string shape = "rectangle";
+
+        file.WriteLine("digraph {");
+
+        var sb = new StringBuilder();
+        foreach (var node in graph.Nodes) {
+          double relativeNodeFrequency = node.Weight / totalNodeWeight;
+          sb.Clear();
+          sb.Append(node.Label + " (" + String.Format("{0:0.00}", node.AverageArity) + ")\\n" + String.Format("{0:0.00%}", relativeNodeFrequency));
+          if (node.Positions != null) {
+            double posSum = node.Positions.Sum(x => x.Value);
+            sb.Append("\\n");
+            foreach (var pos in node.Positions)
+              sb.Append(String.Format("{0:00%} ", pos.Value / posSum));
+          }
+
+          file.WriteLine("\t\"" + node.Label + "\" [shape=" + shape + ", label=\"" + sb + "\", color=\"1.000 0.000 "
+                         + (0.5 - relativeNodeFrequency) + "\"]");
+          if (node.OutEdges == null) continue;
+          double sum = node.OutEdges.Sum(a => a.Weight);
+          foreach (var arc in node.OutEdges) {
+            double relativeArcFrequency = arc.Weight / totalArcWeight;
+            double normWeight = normalizedWeights[arc];
+            sb.Clear();
+            sb.Append("\t\"" + node.Label + "\" -> \"" + ((Vertex)arc.Target).Label + "\"[penwidth=" + normWeight);
+            sb.Append(", label=\"" + String.Format("{0:0.00%}\\n({1:0.00%})", relativeArcFrequency, arc.Weight / sum));
+            sb.Append("\", color=\"1.000 0.000 " + (0.5 - relativeArcFrequency) + "\"]");
+            file.WriteLine(sb);
+          }
+        }
+
+        file.WriteLine("}");
+      }
+    }
+    public static void WriteGml(this IGenericGraph<SymbolNode> graph, string path) {
+      var idMap = new Dictionary<string, int>();
+      const double minNorm = 1.0, maxNorm = 3.0;
+      int idCount = 0;
+
+      var arcs = graph.Nodes.Where(node => node.OutEdges != null).SelectMany(node => node.OutEdges).ToList();
+      double totalArcWeight = arcs.Sum(arc => arc.Weight);
+      double totalNodeWeight = graph.Nodes.Sum(node => node.Weight);
+      var min = arcs.Min(x => x.Weight);
+      var max = arcs.Max(x => x.Weight);
+
+      var normalizedWeights = arcs.Select(arc => new KeyValuePair<SymbolArc, double>(arc, (arc.Weight - min) * (maxNorm - minNorm) / (max - min) + minNorm))
+                                  .ToDictionary(x => x.Key, x => x.Value);
+
+      var nl = Environment.NewLine;
+
+      using (var file = new StreamWriter(path)) {
+        file.WriteLine("graph [" + nl +
+                       "\tcomment \"Pruned symbol graph\"" + nl +
+                       "\tdirected 1");
+
+        var sb = new StringBuilder();
+        foreach (var node in graph.Nodes) {
+          if (!idMap.ContainsKey(node.Label))
+            idMap.Add(node.Label, idCount++);
+          double relativeNodeFrequency = node.Weight / totalNodeWeight;
+          sb.Clear();
+          sb.Append(node.Label + " (" + String.Format("{0:0.00}", node.AverageArity) + ") " +
+                    String.Format("{0:0.00%}", relativeNodeFrequency));
+          if (node.Positions != null) {
+            double posSum = node.Positions.Sum(x => x.Value);
+            //            sb.Append("\\n");
+            foreach (var pos in node.Positions)
+              sb.Append(String.Format("{0:00%} ", pos.Value / posSum));
+          }
+
+          file.WriteLine("\tnode [" + nl +
+                         "\t\tid " + idMap[node.Label] + nl +
+                         "\t\tlabel \"" + node.Label + "\"" + nl + "\t]");
+        }
+
+        foreach (var node in graph.Nodes) {
+          if (node.OutEdges == null) continue;
+          double sum = node.OutEdges.Sum(a => a.Weight);
+          foreach (var arc in node.OutEdges) {
+            double relativeArcFrequency = arc.Weight / totalArcWeight;
+            double normWeight = normalizedWeights[arc];
+            sb.Clear();
+            sb.Append("\tedge [" + nl +
+                      "\t\tsource " + idMap[node.Label] + nl +
+                      "\t\ttarget " + idMap[(arc.Target as SymbolNode).Label] + nl +
+                      "\t\tlabel \"" + String.Format("{0:0.00%}) ({1:0.00%})", relativeArcFrequency, arc.Weight / sum) + "\"" + nl + "\t]");
+            file.WriteLine(sb);
+          }
+        }
+
+        file.WriteLine("]");
+      }
+    }
+
+    public static void WriteDot(this FPGraph graph, string path) {
+      var nl = Environment.NewLine;
+      const string shape = "rectangle";
+
+      using (var file = new StreamWriter(path)) {
+        var sb = new StringBuilder();
+        file.WriteLine("digraph {");
+        foreach (var level in graph.Levels) {
+          foreach (var node in level.Value) {
+            file.WriteLine("\t\"" + node.Label + ":" + level.Key + "\" [shape=" + shape + ", label=\"" + node.Label + "\", rank=same]");
+          }
+        }
+        foreach (var level in graph.Levels) {
+          foreach (var node in level.Value) {
+            if (node.OutEdges == null || node.OutEdges.Count == 0) continue;
+            foreach (var arc in node.OutEdges) {
+              sb.Clear();
+              sb.Append("\t\"" + node.Label + ":" + level.Key + "\" -> \"" + arc.Target.Label + ":" + (level.Key + 1) + "\"");
+              file.WriteLine(sb);
+            }
+          }
+        }
+        file.WriteLine("}");
+      }
+    }
+
+    public static string ToHex(this Color color) {
+      return "#" + color.R.ToString("X2") + color.G.ToString("X2") + color.B.ToString("X2") + color.A.ToString("X2");
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Plugin.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Plugin.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Plugin.cs	(revision 10265)
@@ -0,0 +1,46 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [Plugin("HeuristicLab.EvolutionaryTracking", "Provides operators and related classes for tracking the evolution within a GA.", "3.4.2.7439")]
+  [PluginFile("HeuristicLab.EvolutionaryTracking-3.4.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "3.4")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  [PluginDependency("HeuristicLab.Selection", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.DataAnalysis.Symbolic.Regression", "3.4")]
+  [PluginDependency("HeuristicLab.Problems.DataAnalysis.Symbolic", "3.4")]
+  [PluginDependency("HeuristicLab.Problems.DataAnalysis", "3.4")]
+
+  public class HeuristicLabEvolutionaryTrackingPlugin : PluginBase {
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Properties/AssemblyInfo.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Properties/AssemblyInfo.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Properties/AssemblyInfo.cs	(revision 10265)
@@ -0,0 +1,36 @@
+﻿using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.EvolutionaryTracking")]
+[assembly: AssemblyDescription("Provides operators and related classes for tracking the evolution within a GA.")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2012 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("410e1c1e-c991-49cd-843d-35a741927e4d")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.4.0.0")]
+[assembly: AssemblyFileVersion("3.4.2.7280")]
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/SymbolGraph.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/SymbolGraph.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/SymbolGraph.cs	(revision 10265)
@@ -0,0 +1,76 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [Item("Symbol graph", "A graph used to store the relationship between symbols in a population of individuals")]
+  [StorableClass]
+  public class SymbolGraph : GenericGraph<SymbolNode> {
+    [Storable]
+    private Dictionary<string, SymbolNode> nodes = new Dictionary<string, SymbolNode>();
+
+    public override void AddNode(SymbolNode node) {
+      if (nodes.ContainsKey(node.Label)) return; // node already present? do nothing
+      nodes[node.Label] = node;
+      base.AddNode(node);
+    }
+
+    public bool ContainsKey(string key) {
+      return nodes.ContainsKey(key);
+    }
+
+    public SymbolNode GetNode(string key) {
+      SymbolNode node;
+      nodes.TryGetValue(key, out node);
+      return node;
+    }
+
+    void AddArc(SymbolNode source, SymbolNode target, double weight, object data = null) {
+      source.AddForwardArc(target, weight, data);
+    }
+  }
+
+  [StorableClass]
+  public class SymbolNode : Vertex {
+    public ISymbol Symbol { get; set; }
+    public Dictionary<int, int> Positions { get; set; }
+    public double AverageArity { get; set; }
+
+    public new List<SymbolArc> InEdges {
+      get { return base.InEdges == null ? null : base.InEdges.Cast<SymbolArc>().ToList(); }
+    }
+
+    public new List<SymbolArc> OutEdges {
+      get { return base.OutEdges == null ? null : base.OutEdges.Cast<SymbolArc>().ToList(); }
+    }
+  }
+
+  public class SymbolArc : IEdge {
+    public IVertex Source { get; set; }
+    public IVertex Target { get; set; }
+    public double Weight { get; set; }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/SymbolicExpressionTreeGenealogyGraph/SymbolicExpressionTreeGenealogyGraph.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/SymbolicExpressionTreeGenealogyGraph/SymbolicExpressionTreeGenealogyGraph.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/SymbolicExpressionTreeGenealogyGraph/SymbolicExpressionTreeGenealogyGraph.cs	(revision 10265)
@@ -0,0 +1,111 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [Item("SymbolicExpressionTreeGenealogyGraph", "A genealogy graph for symbolic expression tree individuals")]
+  [StorableClass]
+  public sealed class SymbolicExpressionTreeGenealogyGraph : GenericGraph<SymbolicExpressionTreeGenealogyGraphNode>,
+                                                             ISymbolicExpressionTreeGenealogyGraph, IDisposable {
+    [Storable]
+    private readonly Dictionary<ISymbolicExpressionTree, List<SymbolicExpressionTreeGenealogyGraphNode>> nodeMap
+      = new Dictionary<ISymbolicExpressionTree, List<SymbolicExpressionTreeGenealogyGraphNode>>();
+
+    public SymbolicExpressionTreeGenealogyGraph() {
+    }
+
+    public void Updated() {
+      var updated = GraphUpdated;
+      if (updated != null) updated(this, null);
+    }
+
+    [StorableConstructor]
+    public SymbolicExpressionTreeGenealogyGraph(bool serializing)
+      : base(serializing) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreeGenealogyGraph(this, cloner);
+    }
+
+    private SymbolicExpressionTreeGenealogyGraph(SymbolicExpressionTreeGenealogyGraph original, Cloner cloner)
+      : base(original, cloner) {
+      nodeMap = new Dictionary<ISymbolicExpressionTree, List<SymbolicExpressionTreeGenealogyGraphNode>>(original.nodeMap);
+    }
+
+    public override void AddNode(SymbolicExpressionTreeGenealogyGraphNode node) {
+      var tree = node.SymbolicExpressionTree;
+      if (nodeMap.ContainsKey(tree))
+        nodeMap[tree].Add(node);
+      else
+        nodeMap[tree] = new List<SymbolicExpressionTreeGenealogyGraphNode> { node };
+      base.AddNode(node);
+      // the genealogy graph should have as many nodes as individuals in the population multiplied by the number of generations
+      // plus a number of intermediate individuals ~= mutation probability * population size
+    }
+
+    public bool ContainsIndividual(ISymbolicExpressionTree tree) {
+      return nodeMap.ContainsKey(tree);
+    }
+
+    public List<SymbolicExpressionTreeGenealogyGraphNode> GetGraphNodes(ISymbolicExpressionTree tree) {
+      return nodeMap.ContainsKey(tree) ? nodeMap[tree] : null;
+    }
+    // TODO: make sure a and b are valid and the info exists for both
+    public int Compare(SymbolicExpressionTreeGenealogyGraphNode a, SymbolicExpressionTreeGenealogyGraphNode b) {
+      if (a.Quality.Equals(b.Quality)) {
+        if (a.IsElite) return +1;
+        if (b.IsElite) return -1;
+      }
+      return a.Quality.CompareTo(b.Quality);
+    }
+
+    public SymbolicExpressionTreeGenealogyGraphNode MostRecentCommonAncestor() {
+      double currentRank = Nodes.Last().Rank;
+      var currentGen = Nodes.Where(n => n.Rank.IsAlmost(currentRank)).ToList();
+      var lineages = currentGen.Select(n => n.RootLineage().ToArray()).ToArray();
+      for (int i = 0; i < (int)currentRank; ++i) {
+        if (lineages.All(lineage => lineages[0][i].SymbolicExpressionTree == lineage[i].SymbolicExpressionTree))
+          return lineages[0][i];
+      }
+      return null;
+    }
+
+    public void Dispose() {
+      Nodes.Clear();
+      nodeMap.Clear();
+      // call GC.SupressFinalize?
+    }
+
+    public event EventHandler GraphUpdated;
+    private void OnGraphUpdated(object sender, EventArgs args) {
+      var updated = GraphUpdated;
+      if (updated != null) updated(sender, args);
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/SymbolicExpressionTreeGenealogyGraph/SymbolicExpressionTreeGenealogyGraphNode.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/SymbolicExpressionTreeGenealogyGraph/SymbolicExpressionTreeGenealogyGraphNode.cs	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/SymbolicExpressionTreeGenealogyGraph/SymbolicExpressionTreeGenealogyGraphNode.cs	(revision 10265)
@@ -0,0 +1,83 @@
+﻿
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.EvolutionaryTracking {
+  [StorableClass]
+  public class SymbolicExpressionTreeGenealogyGraphNode : Vertex {
+    public ISymbolicExpressionTree SymbolicExpressionTree {
+      get { return (ISymbolicExpressionTree)Content; }
+      set { Content = value; }
+    }
+
+    [Storable]
+    private double quality;
+    public double Quality { get { return quality; } set { quality = value; } }
+    [Storable]
+    private bool isElite;
+    public bool IsElite { get { return isElite; } set { isElite = value; } }
+    [Storable]
+    private double rank;
+    public double Rank { get { return rank; } set { rank = value; } }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (Id == null) throw new Exception();
+    }
+
+    [StorableConstructor]
+    public SymbolicExpressionTreeGenealogyGraphNode(bool deserializing)
+      : base(deserializing) {
+    }
+
+    public SymbolicExpressionTreeGenealogyGraphNode() {
+    }
+
+    private SymbolicExpressionTreeGenealogyGraphNode(SymbolicExpressionTreeGenealogyGraphNode original, Cloner cloner)
+      : base(original, cloner) {
+      Quality = original.Quality;
+      IsElite = original.IsElite;
+      Rank = original.Rank;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicExpressionTreeGenealogyGraphNode(this, cloner);
+    }
+
+    public new IEnumerable<SymbolicExpressionTreeGenealogyGraphNode> Ancestors() {
+      return base.Ancestors().Cast<SymbolicExpressionTreeGenealogyGraphNode>();
+    }
+
+    public new IEnumerable<SymbolicExpressionTreeGenealogyGraphNode> Descendants() {
+      return base.Descendants().Cast<SymbolicExpressionTreeGenealogyGraphNode>();
+    }
+
+    public IEnumerable<SymbolicExpressionTreeGenealogyGraphNode> RootLineage() {
+      var lineage = new List<SymbolicExpressionTreeGenealogyGraphNode> { this };
+      int i = 0;
+      while (i != lineage.Count) {
+        if (lineage[i].InEdges != null) {
+          lineage.Add((SymbolicExpressionTreeGenealogyGraphNode)lineage[i].InEdges[0].Source);
+        }
+        ++i;
+      }
+      return lineage;
+    }
+
+    public new List<Arc> InEdges {
+      get {
+        return base.InEdges == null ? null : base.InEdges.Cast<Arc>().ToList();
+      }
+    }
+
+    public new List<Arc> OutEdges {
+      get {
+        return base.OutEdges == null ? null : base.InEdges.Cast<Arc>().ToList();
+      }
+    }
+  }
+}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj	(revision 10265)
@@ -0,0 +1,183 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{318DFE8C-CA23-4F1B-A4AC-62B425060241}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.EvolutionaryTracking.Views</RootNamespace>
+    <AssemblyName>HeuristicLab.EvolutionaryTracking.Views-3.4</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.MainForm-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.MainForm.WindowsForms-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis-3.4.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Visualization-3.3, Version=3.3.0.5170, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Visualization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AncestryLayoutAdapter.cs" />
+    <Compile Include="ExtendedSymbolicExpressionTreeCanvas.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="FrequentFragmentsDialog.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="FrequentFragmentsDialog.Designer.cs">
+      <DependentUpon>FrequentFragmentsDialog.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GenealogyGraphChart.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="GenealogyGraphChart.Designer.cs">
+      <DependentUpon>GenealogyGraphChart.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GenealogyGraphDialog.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="GenealogyGraphDialog.designer.cs">
+      <DependentUpon>GenealogyGraphDialog.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GenealogyGraphView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="GenealogyGraphView.Designer.cs">
+      <DependentUpon>GenealogyGraphView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="LineageExplorerView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="LineageExplorerView.Designer.cs">
+      <DependentUpon>LineageExplorerView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Primitives\LabeledEllipse.cs" />
+    <Compile Include="Primitives\LabeledRectangle.cs" />
+    <Compile Include="Primitives\PrimitiveGroup.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="VisualGenealogyGraphArc.cs" />
+    <Compile Include="VisualGenealogyGraphNode.cs" />
+    <Compile Include="VisualGenealogyGraphTextLabel.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.EvolutionaryTracking\3.4\HeuristicLab.EvolutionTracking-3.4.csproj">
+      <Project>{1f75cea3-464f-4a6f-b2f0-04b9841ebc16}</Project>
+      <Name>HeuristicLab.EvolutionTracking-3.4</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj.user
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj.user	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj.user	(revision 10265)
@@ -0,0 +1,6 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectView>ShowAllFiles</ProjectView>
+  </PropertyGroup>
+</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionaryTracking.Views-3.4.csproj
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionaryTracking.Views-3.4.csproj	(revision 10264)
+++ 	(revision )
@@ -1,198 +1,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>8.0.30703</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{318DFE8C-CA23-4F1B-A4AC-62B425060241}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>HeuristicLab.EvolutionaryTracking.Views</RootNamespace>
-    <AssemblyName>HeuristicLab.EvolutionaryTracking.Views-3.4</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup>
-    <SignAssembly>true</SignAssembly>
-  </PropertyGroup>
-  <PropertyGroup>
-    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="HeuristicLab.Common-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Core-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Core.Views-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.MainForm-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.MainForm-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.MainForm.WindowsForms-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis-3.4.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Visualization-3.3, Version=3.3.0.5170, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Visualization-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Drawing" />
-    <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="AncestryLayoutAdapter.cs" />
-    <Compile Include="ExtendedSymbolicExpressionTreeCanvas.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="FrequentFragmentsDialog.cs">
-      <SubType>Form</SubType>
-    </Compile>
-    <Compile Include="FrequentFragmentsDialog.Designer.cs">
-      <DependentUpon>FrequentFragmentsDialog.cs</DependentUpon>
-    </Compile>
-    <Compile Include="GenealogyGraphChart.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="GenealogyGraphChart.Designer.cs">
-      <DependentUpon>GenealogyGraphChart.cs</DependentUpon>
-    </Compile>
-    <Compile Include="GenealogyGraphDialog.cs">
-      <SubType>Form</SubType>
-    </Compile>
-    <Compile Include="GenealogyGraphDialog.designer.cs">
-      <DependentUpon>GenealogyGraphDialog.cs</DependentUpon>
-    </Compile>
-    <Compile Include="GenealogyGraphView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="GenealogyGraphView.Designer.cs">
-      <DependentUpon>GenealogyGraphView.cs</DependentUpon>
-    </Compile>
-    <Compile Include="LineageExplorerView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="LineageExplorerView.Designer.cs">
-      <DependentUpon>LineageExplorerView.cs</DependentUpon>
-    </Compile>
-    <Compile Include="Plugin.cs" />
-    <Compile Include="Primitives\LabeledEllipse.cs" />
-    <Compile Include="Primitives\LabeledRectangle.cs" />
-    <Compile Include="Primitives\PrimitiveGroup.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Properties\Resources.Designer.cs">
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
-      <DependentUpon>Resources.resx</DependentUpon>
-    </Compile>
-    <Compile Include="VisualGenealogyGraphArc.cs" />
-    <Compile Include="VisualGenealogyGraphNode.cs" />
-    <Compile Include="VisualGenealogyGraphTextLabel.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views\3.4\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views-3.4.csproj">
-      <Project>{423bd94f-963a-438e-ba45-3bb3d61cd03b}</Project>
-      <Name>HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views-3.4</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.4\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj">
-      <Project>{06d4a186-9319-48a0-bade-a2058d462eea}</Project>
-      <Name>HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.EvolutionaryTracking\3.4\HeuristicLab.EvolutionaryTracking-3.4.csproj">
-      <Project>{1f75cea3-464f-4a6f-b2f0-04b9841ebc16}</Project>
-      <Name>HeuristicLab.EvolutionaryTracking-3.4</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis.Symbolic\3.4\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj">
-      <Project>{3D28463F-EC96-4D82-AFEE-38BE91A0CA00}</Project>
-      <Name>HeuristicLab.Problems.DataAnalysis.Symbolic-3.4</Name>
-      <Private>False</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="HeuristicLab.snk" />
-  </ItemGroup>
-  <ItemGroup>
-    <EmbeddedResource Include="Properties\Resources.resx">
-      <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
-    </EmbeddedResource>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionaryTracking.Views-3.4.csproj.user
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/HeuristicLab.EvolutionaryTracking.Views-3.4.csproj.user	(revision 10264)
+++ 	(revision )
@@ -1,6 +1,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <ProjectView>ShowAllFiles</ProjectView>
-  </PropertyGroup>
-</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/Plugin.cs.frame
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/Plugin.cs.frame	(revision 10264)
+++ 	(revision )
@@ -1,41 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using HeuristicLab.PluginInfrastructure;
-
-namespace HeuristicLab.EvolutionaryTracking {
-  [Plugin("HeuristicLab.EvolutionaryTracking", "Provides operators and related classes for tracking the evolution within a GA.", "3.4.2.7439")]
-  [PluginFile("HeuristicLab.EvolutionaryTracking-3.4.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.Collections", "3.3")]
-  [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Core", "3.3")]
-  [PluginDependency("HeuristicLab.Data", "3.3")]
-  [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "3.4")]
-  [PluginDependency("HeuristicLab.Operators", "3.3")]
-  [PluginDependency("HeuristicLab.Optimization", "3.3")]
-  [PluginDependency("HeuristicLab.Parameters", "3.3")]
-  [PluginDependency("HeuristicLab.Persistence", "3.3")]
-  public class HeuristicLabEvolutionaryTrackingPlugin : PluginBase {
-  }
-}
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/Primitives/LabeledEllipse.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/Primitives/LabeledEllipse.cs	(revision 10264)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/Primitives/LabeledEllipse.cs	(revision 10265)
@@ -23,8 +23,7 @@
 using System.Drawing;
 using System.Linq;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Visualization;
 
-namespace HeuristicLab.EvolutionaryTracking.Views {
+namespace HeuristicLab.EvolutionaryTracking.Views.Primitives {
   public class LabeledEllipse : Ellipse, ILayoutNode<ISymbolicExpressionTreeNode> {
     private string text;
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/Primitives/LabeledRectangle.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/Primitives/LabeledRectangle.cs	(revision 10264)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/Primitives/LabeledRectangle.cs	(revision 10265)
@@ -23,9 +23,8 @@
 using System.Drawing;
 using System.Linq;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Visualization;
 using Rectangle = HeuristicLab.Visualization.Rectangle;
 
-namespace HeuristicLab.EvolutionaryTracking.Views {
+namespace HeuristicLab.EvolutionaryTracking.Views.Primitives {
   public class LabeledRectangle : Rectangle, ILayoutNode<ISymbolicExpressionTreeNode> {
     private string text;
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj	(revision 10265)
@@ -0,0 +1,180 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.EvolutionaryTracking</RootNamespace>
+    <AssemblyName>HeuristicLab.EvolutionaryTracking-3.4</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.Analysis-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Analyzers\BuildingBlocks\RelevantBuildingBlocksAnalyzer.cs" />
+    <Compile Include="Analyzers\BuildingBlocks\Poly10BuildingBlocksAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreePruningAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreeShapeAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreeEvolvabilityAnalyzer.cs" />
+    <Compile Include="Analyzers\Fragments\SymbolicExpressionTreeRelativeFragmentDepthAnalyzer.cs" />
+    <Compile Include="Analyzers\Fragments\SymbolicExpressionTreeFragmentLengthsAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreeFrequentPatternsAnalyzer.cs" />
+    <Compile Include="Analyzers\Fragments\SymbolicExpressionTreeFragmentsAnalyzer.cs" />
+    <Compile Include="FPGraph.cs" />
+    <Compile Include="Interfaces\IEdge.cs" />
+    <Compile Include="LineageExplorer.cs" />
+    <Compile Include="Operators\LineageAggregator.cs" />
+    <Compile Include="Operators\SymbolicExpressionTreeFPBuilder.cs" />
+    <Compile Include="Operators\SymbolicExpressionTreeGenealogyGraphBuilder.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreePopulationDiversityAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreeRelativeLengthAnalyzer.cs" />
+    <Compile Include="GenericGraph\GenericGraph.cs" />
+    <Compile Include="GenericGraph\Arc.cs" />
+    <Compile Include="GenericGraph\Vertex.cs" />
+    <Compile Include="Interfaces\IGenericGraph.cs" />
+    <Compile Include="Interfaces\IVertex.cs" />
+    <Compile Include="Interfaces\ISymbolicExpressionTreeGenealogyGraph.cs" />
+    <Compile Include="Operators\CleanupOperator.cs" />
+    <Compile Include="Operators\SymbolicExpressionTreeSymbolGraphBuilder.cs" />
+    <Compile Include="Operators\Util.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SymbolGraph.cs" />
+    <Compile Include="SymbolicExpressionTreeGenealogyGraph\SymbolicExpressionTreeGenealogyGraph.cs" />
+    <Compile Include="SymbolicExpressionTreeGenealogyGraph\SymbolicExpressionTreeGenealogyGraphNode.cs" />
+  </ItemGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <WCFMetadata Include="Service References\" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj.user
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj.user	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj.user	(revision 10265)
@@ -0,0 +1,6 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectView>ProjectFiles</ProjectView>
+  </PropertyGroup>
+</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionaryTracking-3.4.csproj
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionaryTracking-3.4.csproj	(revision 10264)
+++ 	(revision )
@@ -1,197 +1,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>8.0.30703</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>HeuristicLab.EvolutionaryTracking</RootNamespace>
-    <AssemblyName>HeuristicLab.EvolutionaryTracking-3.4</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup>
-    <SignAssembly>true</SignAssembly>
-  </PropertyGroup>
-  <PropertyGroup>
-    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="HeuristicLab.Analysis-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Collections-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Common-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Core-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Core.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Data-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.MainForm-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Operators-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Optimization-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Parameters-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Persistence-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Drawing" />
-    <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Analyzers\BuildingBlocks\RelevantBuildingBlocksAnalyzer.cs" />
-    <Compile Include="Analyzers\BuildingBlocks\Poly10BuildingBlocksAnalyzer.cs" />
-    <Compile Include="Analyzers\SymbolicExpressionTreePruningAnalyzer.cs" />
-    <Compile Include="Analyzers\SymbolicExpressionTreeShapeAnalyzer.cs" />
-    <Compile Include="Analyzers\SymbolicExpressionTreeEvolvabilityAnalyzer.cs" />
-    <Compile Include="Analyzers\Fragments\SymbolicExpressionTreeRelativeFragmentDepthAnalyzer.cs" />
-    <Compile Include="Analyzers\Fragments\SymbolicExpressionTreeFragmentLengthsAnalyzer.cs" />
-    <Compile Include="Analyzers\SymbolicExpressionTreeFrequentPatternsAnalyzer.cs" />
-    <Compile Include="Analyzers\Fragments\SymbolicExpressionTreeFragmentsAnalyzer.cs" />
-    <Compile Include="FPGraph.cs" />
-    <Compile Include="Interfaces\IEdge.cs" />
-    <Compile Include="LineageExplorer.cs" />
-    <Compile Include="Operators\LineageAggregator.cs" />
-    <Compile Include="Operators\SymbolicExpressionTreeFPBuilder.cs" />
-    <Compile Include="Operators\SymbolicExpressionTreeGenealogyGraphBuilder.cs" />
-    <Compile Include="Analyzers\SymbolicExpressionTreePopulationDiversityAnalyzer.cs" />
-    <Compile Include="Analyzers\SymbolicExpressionTreeRelativeLengthAnalyzer.cs" />
-    <Compile Include="GenericGraph\GenericGraph.cs" />
-    <Compile Include="GenericGraph\Arc.cs" />
-    <Compile Include="GenericGraph\Vertex.cs" />
-    <Compile Include="Interfaces\IGenericGraph.cs" />
-    <Compile Include="Interfaces\IVertex.cs" />
-    <Compile Include="Interfaces\ISymbolicExpressionTreeGenealogyGraph.cs" />
-    <Compile Include="Operators\CleanupOperator.cs" />
-    <Compile Include="Operators\SymbolicExpressionTreeSymbolGraphBuilder.cs" />
-    <Compile Include="Operators\Util.cs" />
-    <Compile Include="Plugin.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SymbolGraph.cs" />
-    <Compile Include="SymbolicExpressionTreeGenealogyGraph\SymbolicExpressionTreeGenealogyGraph.cs" />
-    <Compile Include="SymbolicExpressionTreeGenealogyGraph\SymbolicExpressionTreeGenealogyGraphNode.cs" />
-  </ItemGroup>
-  <ItemGroup />
-  <ItemGroup>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.4\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj">
-      <Project>{06D4A186-9319-48A0-BADE-A2058D462EEA}</Project>
-      <Name>HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis.Symbolic\3.4\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj">
-      <Project>{3d28463f-ec96-4d82-afee-38be91a0ca00}</Project>
-      <Name>HeuristicLab.Problems.DataAnalysis.Symbolic-3.4</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Selection\3.3\HeuristicLab.Selection-3.3.csproj">
-      <Project>{2C36CD4F-E5F5-43A4-801A-201EA895FE17}</Project>
-      <Name>HeuristicLab.Selection-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <WCFMetadata Include="Service References\" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="HeuristicLab.snk" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionaryTracking-3.4.csproj.user
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionaryTracking/3.4/HeuristicLab.EvolutionaryTracking-3.4.csproj.user	(revision 10264)
+++ 	(revision )
@@ -1,6 +1,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <ProjectView>ProjectFiles</ProjectView>
-  </PropertyGroup>
-</Project>
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Tracking.sln
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.Tracking.sln	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.Tracking.sln	(revision 10265)
@@ -0,0 +1,64 @@
+﻿
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.21005.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{C80F4C35-CB87-4695-8A53-6F2D08275253}"
+	ProjectSection(SolutionItems) = preProject
+		Build.cmd = Build.cmd
+		HeuristicLab.Tracking.vsmdi = HeuristicLab.Tracking.vsmdi
+		Local.testsettings = Local.testsettings
+		PreBuildEvent.cmd = PreBuildEvent.cmd
+		TraceAndTestImpact.testsettings = TraceAndTestImpact.testsettings
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.EvolutionTracking-3.4", "HeuristicLab.EvolutionaryTracking\3.4\HeuristicLab.EvolutionTracking-3.4.csproj", "{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.EvolutionTracking.Views-3.4", "HeuristicLab.EvolutionaryTracking.Views\3.4\HeuristicLab.EvolutionTracking.Views-3.4.csproj", "{318DFE8C-CA23-4F1B-A4AC-62B425060241}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|Mixed Platforms = Debug|Mixed Platforms
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|Mixed Platforms = Release|Mixed Platforms
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Release|x64.ActiveCfg = Release|x64
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Release|x64.Build.0 = Release|x64
+		{1F75CEA3-464F-4A6F-B2F0-04B9841EBC16}.Release|x86.ActiveCfg = Release|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Release|Any CPU.Build.0 = Release|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Release|x64.ActiveCfg = Release|x64
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Release|x64.Build.0 = Release|x64
+		{318DFE8C-CA23-4F1B-A4AC-62B425060241}.Release|x86.ActiveCfg = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(TestCaseManagementSettings) = postSolution
+		CategoryFile = HeuristicLab.Tracking.vsmdi
+	EndGlobalSection
+EndGlobal
Index: branches/HeuristicLab.EvolutionTracking/PreBuildEvent.cmd
===================================================================
--- branches/HeuristicLab.EvolutionTracking/PreBuildEvent.cmd	(revision 10265)
+++ branches/HeuristicLab.EvolutionTracking/PreBuildEvent.cmd	(revision 10265)
@@ -0,0 +1,2 @@
+SubWCRev "%ProjectDir%\" "%ProjectDir%\Properties\AssemblyInfo.frame" "%ProjectDir%\Properties\AssemblyInfo.cs"
+SubWCRev "%ProjectDir%\" "%ProjectDir%\Plugin.cs.frame" "%ProjectDir%\Plugin.cs"
