Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs	(revision 7792)
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/TracingSymbolicExpressionTreeCrossover.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/TracingSymbolicExpressionTreeCrossover.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/TracingSymbolicExpressionTreeCrossover.cs	(revision 7792)
@@ -21,4 +21,5 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
@@ -35,6 +36,5 @@
   /// A base class for operators that perform a crossover of symbolic expression trees.
   /// </summary>
-  [Item("SymbolicExpressionTreeCrossover",
-    "A base class for operators that perform a crossover of symbolic expression trees.")]
+  [Item("SymbolicExpressionTreeCrossover", "A base class for operators that perform a crossover of symbolic expression trees.")]
   [StorableClass]
   public abstract class TracingSymbolicExpressionTreeCrossover : SymbolicExpressionTreeOperator, ISymbolicExpressionTreeCrossover {
@@ -46,50 +46,38 @@
 
     #region Parameter Properties
-
     public ILookupParameter<ItemArray<ISymbolicExpressionTree>> ParentsParameter {
       get { return (ScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[ParentsParameterName]; }
     }
-
     public ILookupParameter<ISymbolicExpressionTree> ChildParameter {
       get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[ChildParameterName]; }
     }
-
     public LookupParameter<CloneMapType> GlobalCloneMapParameter {
       get { return (LookupParameter<CloneMapType>)Parameters[GlobalCloneMapParameterName]; }
     }
-
     public LookupParameter<TraceMapType> GlobalTraceMapParameter {
       get { return (LookupParameter<TraceMapType>)Parameters[GlobalTraceMapParameterName]; }
     }
-
     public LookupParameter<CloneMapType> GlobalFragmentMapParameter {
       get { return (LookupParameter<CloneMapType>)Parameters[GlobalFragmentMapParameterName]; }
     }
-
     #endregion
 
     #region Properties
-
     public ItemArray<ISymbolicExpressionTree> Parents {
       get { return ParentsParameter.ActualValue; }
     }
-
     public ISymbolicExpressionTree Child {
       get { return ChildParameter.ActualValue; }
       set { ChildParameter.ActualValue = value; }
     }
-
     public CloneMapType GlobalCloneMap {
       get { return GlobalCloneMapParameter.ActualValue; }
     }
-
+    public TraceMapType GlobalTraceMap {
+      get { return GlobalTraceMapParameter.ActualValue; }
+    }
     public CloneMapType GlobalFragmentMap {
       get { return GlobalFragmentMapParameter.ActualValue; }
     }
-
-    public TraceMapType GlobalTraceMap {
-      get { return GlobalTraceMapParameter.ActualValue; }
-    }
-
     #endregion
 
@@ -105,14 +93,9 @@
     protected TracingSymbolicExpressionTreeCrossover()
       : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(ParentsParameterName,
-                                                                           "The parent symbolic expression trees which should be crossed."));
-      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(ChildParameterName,
-                                                                  "The child symbolic expression tree resulting from the crossover."));
-      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 LookupParameter<TraceMapType>(GlobalTraceMapParameterName,
-                                                       "A global cache containing tracing info."));
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(ParentsParameterName, "The parent symbolic expression trees which should be crossed."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(ChildParameterName, "The child symbolic expression tree resulting from the crossover."));
+      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 LookupParameter<TraceMapType>(GlobalTraceMapParameterName, "A global cache containing tracing info."));
     }
 
@@ -120,19 +103,26 @@
       if (Parents.Length != 2)
         throw new ArgumentException("Number of parents must be exactly two for symbolic expression tree crossover operators.");
+
       // add global trace cache if not already present in global scope
       var gScope = ExecutionContext.Scope;
-      while (gScope.Parent != null) gScope = gScope.Parent;
+      while (gScope.Parent != null)
+        gScope = gScope.Parent;
       if (GlobalTraceMap == null)
         gScope.Variables.Add(new Variable(GlobalTraceMapParameterName, new TraceMapType()));
       if (GlobalFragmentMap == null)
         gScope.Variables.Add(new Variable(GlobalFragmentMapParameterName, new CloneMapType()));
-      // get original parents
+
+      // get original parents (this info will be needed later to construct the genealogy graph)
       var originalParents = new ItemList<IItem>(Parents.Select(x => GlobalCloneMap[x]));
+
       // save the nodes of parent0 in a list so we can track what modifications are made by crossover
-      var nodes0 = Parents[0].IterateNodes().ToList();
+      var nodes0 = Parents[0].IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+
       //perform crossover
       Child = Crossover(Random, Parents[0], Parents[1]);
+
       // create another list of parent0's nodes, so we can compare it with the first list to see what changed
-      var nodes1 = Child.IterateNodes().ToList();
+      var nodes1 = Child.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+
       // compare the two nodes lists and check the difference (comparing node references so we avoid false functional identity). 
       // if no difference is found, then it is assumed that the whole tree was swapped with itself (it can happen), so the index is 0
@@ -141,6 +131,8 @@
         if (nodes0[i] != nodes1[i]) break;
       if (i == min) i = 0;
-      GlobalTraceMap[Child] = originalParents;
-      GlobalFragmentMap[Child] = new IntValue(i);
+
+      // add heredity information into the global variables
+      GlobalTraceMap[Child] = originalParents; // map child to its corresponding parents from the previous generation
+      GlobalFragmentMap[Child] = new IntValue(i); // map child to the index of its fragment
       return base.Apply();
     }
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTree.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTree.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTree.cs	(revision 7792)
@@ -31,4 +31,5 @@
     IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPrefix();
     IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPostfix();
+    IEnumerable<ISymbolicExpressionTreeNode> IterateNodesBreadth();
   }
 }
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs	(revision 7792)
@@ -36,4 +36,5 @@
     IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPostfix();
     IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPrefix();
+    IEnumerable<ISymbolicExpressionTreeNode> IterateNodesBreadth();
     void ForEachNodePostfix(Action<ISymbolicExpressionTreeNode> a);
     void ForEachNodePrefix(Action<ISymbolicExpressionTreeNode> a);
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/TracingSymbolicExpressionTreeManipulator.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/TracingSymbolicExpressionTreeManipulator.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/TracingSymbolicExpressionTreeManipulator.cs	(revision 7792)
@@ -21,6 +21,8 @@
 
 using System;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -39,4 +41,5 @@
     private const string GlobalTraceMapParameterName = "GlobalTraceMap";
     private const string GlobalCloneMapParameterName = "GlobalCloneMap";
+    private const string GlobalFragmentMapParameterName = "GlobalFragmentMap";
 
     #region Parameter Properties
@@ -49,4 +52,7 @@
     public LookupParameter<TraceMapType> GlobalTraceMapParameter {
       get { return (LookupParameter<TraceMapType>)Parameters[GlobalTraceMapParameterName]; }
+    }
+    public LookupParameter<CloneMapType> GlobalFragmentMapParameter {
+      get { return (LookupParameter<CloneMapType>)Parameters[GlobalFragmentMapParameterName]; }
     }
     #endregion
@@ -62,4 +68,7 @@
       get { return GlobalTraceMapParameter.ActualValue; }
     }
+    public CloneMapType GlobalFragmentMap {
+      get { return GlobalFragmentMapParameter.ActualValue; }
+    }
     #endregion
 
@@ -72,4 +81,5 @@
       Parameters.Add(new LookupParameter<CloneMapType>(GlobalCloneMapParameterName, "A global map keeping track of trees and their clones (made during selection)."));
       Parameters.Add(new LookupParameter<TraceMapType>(GlobalTraceMapParameterName, "A global cache containing tracing info."));
+      Parameters.Add(new LookupParameter<CloneMapType>(GlobalFragmentMapParameterName, "A global map keeping track of tree fragments received via crossover."));
     }
 
@@ -77,21 +87,34 @@
       ISymbolicExpressionTree tree = SymbolicExpressionTreeParameter.ActualValue;
 
-      if (GlobalTraceMap == null) {
-        var gScope = ExecutionContext.Scope;
-        while (gScope.Parent != null) gScope = gScope.Parent;
+      var gScope = ExecutionContext.Scope;
+      while (gScope.Parent != null)
+        gScope = gScope.Parent;
+
+      if (GlobalTraceMap == null)
         gScope.Variables.Add(new Variable(GlobalTraceMapParameterName, new TraceMapType()));
-      }
+      if (GlobalFragmentMap == null)
+        gScope.Variables.Add(new Variable(GlobalFragmentMapParameterName, new CloneMapType()));
+
       if (GlobalTraceMap.ContainsKey(tree)) {
         // tree was affected by crossover before mutation
-        // if the tree to be manipulated is already a product of crossover (in the current reproduction phase), then there exists no relationship with the original "parent". 
+        // if the tree to be manipulated is already a product of crossover (in the current reproduction phase), 
+        // then there exists no relationship with the original "parent". 
         // In order to preserve information, a tree clone is created before mutation and added to the trace map.
         var clone = (IItem)tree.Clone();
         GlobalTraceMap[clone] = GlobalTraceMap[tree];
         GlobalTraceMap[tree] = new ItemList<IItem> { clone };
+        GlobalFragmentMap[clone] = GlobalFragmentMap[tree];
       } else {
         var original = GlobalCloneMap[tree];
         GlobalTraceMap[tree] = new ItemList<IItem> { original };
       }
+      var nodes0 = tree.IterateNodesBreadth().ToList();
       Manipulate(RandomParameter.ActualValue, tree);
+      var nodes1 = tree.IterateNodesBreadth().ToList();
+      int i, min = Math.Max(nodes0.Count, nodes1.Count);
+      for (i = 0; i != min; ++i)
+        if (nodes0[i] != nodes1[i]) break;
+      if (i == min) i = 0;
+      GlobalFragmentMap[tree] = new IntValue(i);
 
       return base.Apply();
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Plugin.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Plugin.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Plugin.cs	(revision 7792)
@@ -26,5 +26,5 @@
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
-  [Plugin("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding","Provides operators and related classes for the symbolic expression tree encoding.", "3.4.2.7785")]
+  [Plugin("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding","Provides operators and related classes for the symbolic expression tree encoding.", "3.4.2.7788")]
   [PluginFile("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Analysis", "3.3")]
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTree.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTree.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTree.cs	(revision 7792)
@@ -85,4 +85,9 @@
       return root.IterateNodesPostfix();
     }
+    public IEnumerable<ISymbolicExpressionTreeNode> IterateNodesBreadth() {
+      if (root == null)
+        return new SymbolicExpressionTreeNode[0];
+      return root.IterateNodesBreadth();
+    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeMatching.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeMatching.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeMatching.cs	(revision 7792)
@@ -70,83 +70,31 @@
 
     public static bool ContainsFragment(this ISymbolicExpressionTree tree, ISymbolicExpressionTreeNode fragment, int mode) {
-      var nodes = tree.IterateNodesPostfix().ToArray();
-      var fragments = fragment.IterateNodesPostfix().ToArray();
+      var nodes = tree.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+      var fragments = fragment.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
       return FindMatch(nodes, fragments, mode) != -1;
     }
 
-    #region FindMatch signatures
-    public static int FindMatch(ISymbolicExpressionTree t0, ISymbolicExpressionTree t1, int mode) {
-      return FindMatch(t0.IterateNodesPostfix().ToArray(), t1.IterateNodesPostfix().ToArray(), mode);
-    }
-    private static int FindMatch(ISymbolicExpressionTreeNode t0, ISymbolicExpressionTreeNode t1, int mode) {
-      return FindMatch(t0.IterateNodesPostfix().ToArray(), t1.IterateNodesPostfix().ToArray(), mode);
-    }
-    private static int FindMatch(ISymbolicExpressionTree t0, ISymbolicExpressionTreeNode t1, int mode) {
-      return FindMatch(t0.IterateNodesPostfix().ToArray(), t1.IterateNodesPostfix().ToArray(), mode);
-    }
-    private static int FindMatch(ISymbolicExpressionTreeNode t0, ISymbolicExpressionTree t1, int mode) {
-      return FindMatch(t0.IterateNodesPostfix().ToArray(), t1.IterateNodesPostfix().ToArray(), mode);
-    }
-    #endregion
-
     // convenience methods for less typing :)
     private static IEnumerator<ISymbolicExpressionTreeNode> Enumerator(this ISymbolicExpressionTree tree) {
-      return tree.IterateNodes().GetEnumerator();
+      return tree.IterateNodesBreadth().GetEnumerator();
     }
     private static IEnumerator<ISymbolicExpressionTreeNode> Enumerator(this ISymbolicExpressionTreeNode tree) {
-      return tree.IterateNodes().GetEnumerator();
+      return tree.IterateNodesBreadth().GetEnumerator();
     }
-    // method for breath-width iteration of nodes
-    public static IEnumerable<ISymbolicExpressionTreeNode> IterateNodes(this ISymbolicExpressionTree tree) {
-      return IterateNodes(tree.Root);
+    public static int FindMatch(ISymbolicExpressionTree a, ISymbolicExpressionTree b, int mode) {
+      var nodesA = a.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+      var nodesB = b.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+      return FindMatch(nodesA, nodesB, mode);
     }
-
-    private static IEnumerable<ISymbolicExpressionTreeNode> IterateNodes(this ISymbolicExpressionTreeNode root) {
-      var list = new List<ISymbolicExpressionTreeNode> { root };
-      int offset = 0, count = 1;
-      while (offset != count) {
-        var c = count;
-        for (int i = offset; i != count; ++i) {
-          yield return list[i]; // TODO: look into yield performance (vs returning the whole list at the end)
-          if (!list[i].Subtrees.Any()) continue;
-          list.AddRange(list[i].Subtrees);
-        }
-        offset = c;
-        count = list.Count;
-      }
-      //return list;
+    public static int FindMatch(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b, int mode) {
+      var nodesA = a.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+      var nodesB = b.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+      return FindMatch(nodesA, nodesB, mode);
     }
-
-    /// <summary>
-    /// This method finds the point where parent and child differ. For instance in the case of crossover, 
-    /// it will return the node that was swapped into parent0 from parent1
-    /// Prerequisites: as the naming implies, heredity should exist between parent and child,
-    /// otherwise this method would not make much sense (it would always return the root of child)
-    /// </summary>
-    /// <param name="parent">The individual from the previous generation that was crossed over or mutated to produce child</param>
-    /// <param name="child">The result of a genetic operation applied on parent</param>
-    /// <returns>A symbolic expression tree node representing the difference fragment between parent and child</returns>
-    public static ISymbolicExpressionTreeNode GetFragmentDiff(ISymbolicExpressionTree parent, ISymbolicExpressionTree child) {
-      var nodes1 = parent.IterateNodes().ToList();
-      var nodes2 = child.IterateNodes().ToList();
-      var e1 = nodes1.AsEnumerable().GetEnumerator();
-      var e2 = nodes2.AsEnumerable().GetEnumerator();
-      while (e1.MoveNext() && e2.MoveNext()) {
-        var comparer = new SymbolicExpressionTreeNodeComparer((int)SimilarityLevel.Exact);
-        if (!comparer.Equals(e1.Current, e2.Current)) {
-          return e2.Current;
-        }
-        //if (!e1.Current.IterateNodes().SequenceEqual(e2.Current.IterateNodes(), comparer)) {
-        //  return e2.Current;
-        //} // return the fragment by which child differs from parent
-      }
-      return null;
-    }
-
     // returns the index in the sequence 'seq', where pattern 'pat' is matched, or -1 for no match
     // -1 means no match, 0 means perfect match (the sequences overlap, hence the match index is 0)
-    public static int FindMatch(ISymbolicExpressionTreeNode[] seq, ISymbolicExpressionTreeNode[] pat, int mode) {
-      int patlen = pat.Length;
-      int seqlen = seq.Length;
+    public static int FindMatch(List<ISymbolicExpressionTreeNode> seq, List<ISymbolicExpressionTreeNode> pat, int mode) {
+      int patlen = pat.Count;
+      int seqlen = seq.Count;
       if (patlen == 0 || seqlen == 0) return -1;
       var comparer = new SymbolicExpressionTreeNodeComparer(mode);
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs	(revision 7792)
@@ -172,6 +172,20 @@
     }
 
+    public IEnumerable<ISymbolicExpressionTreeNode> IterateNodesBreadth() {
+      var list = new List<ISymbolicExpressionTreeNode>(GetLength()) { this };
+      int offset = 0, count = 1;
+      while (offset != count) {
+        var c = count;
+        for (int i = offset; i != count; ++i)
+          if (list[i].SubtreeCount > 0)
+            list.AddRange(list[i].Subtrees);
+        offset = c;
+        count = list.Count;
+      }
+      return list;
+    }
+
     public IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPrefix() {
-      List<ISymbolicExpressionTreeNode> list = new List<ISymbolicExpressionTreeNode>();
+      List<ISymbolicExpressionTreeNode> list = new List<ISymbolicExpressionTreeNode>(GetLength());
       ForEachNodePrefix((n) => list.Add(n));
       return list;
@@ -188,5 +202,5 @@
 
     public IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPostfix() {
-      List<ISymbolicExpressionTreeNode> list = new List<ISymbolicExpressionTreeNode>();
+      List<ISymbolicExpressionTreeNode> list = new List<ISymbolicExpressionTreeNode>(GetLength());
       ForEachNodePostfix((n) => list.Add(n));
       return list;
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphChart.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphChart.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphChart.cs	(revision 7792)
@@ -114,5 +114,5 @@
               style = DashStyle.Dash;
             } else {
-              style = arc.OperatorType == 0 ? DashStyle.Solid : DashStyle.Dash;
+              style = node.InEdges.Count == 2 ? DashStyle.Solid : DashStyle.Dash;
             }
             var arcPen = new Pen(Color.Transparent) { DashStyle = style };
@@ -183,10 +183,4 @@
                 var end = new Point((int)arc.End.X, (int)arc.End.Y);
                 arc.Pen.Brush = new LinearGradientBrush(start, end, arc.Source.ToColor(), arc.Target.ToColor());
-                if (node.Data.CutpointIndex == -1) {
-                  // if the cut index wasn't computed yet
-                  var parent = arc.Source.Data.Data as ISymbolicExpressionTree;
-                  var child = node.Data.Data as ISymbolicExpressionTree;
-                  node.Data.CutpointIndex = GetCutIndex(parent, child);
-                }
               }
             }
@@ -236,18 +230,4 @@
       Chart.EnforceUpdate();
     }
-
-    // maybe this method does't belong here
-    // TODO: find a good location for this kind of functionality
-    private static int GetCutIndex(ISymbolicExpressionTree parent, ISymbolicExpressionTree child) {
-      var e1 = parent.IterateNodesPostfix().GetEnumerator();
-      var e2 = child.IterateNodesPostfix().GetEnumerator();
-      int pos = 0;
-      var comparer = new SymbolicExpressionTreeNodeComparer((int)SymbolicExpressionTreeMatching.SimilarityLevel.Exact);
-      while (e1.MoveNext() && e2.MoveNext() && comparer.Equals(e1.Current, e2.Current)) ++pos;
-      if (pos == 0) return -1;
-      if (pos == child.Length) return 0;
-      return pos;
-      //return pos == 0 ? -1 : pos;
-    }
   }
 }
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphView.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphView.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphView.cs	(revision 7792)
@@ -21,4 +21,5 @@
 
 using System;
+using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
@@ -92,9 +93,9 @@
       symbolicExpressionTreeChart.Tree = (ISymbolicExpressionTree)genealogyGraphNode.Data;
       if (_selectedVisualSymbolicExpressionTreeNode != null) {
-        var nodes = symbolicExpressionTreeChart.Tree.IterateNodesPostfix().ToArray();
-        var fragments = _selectedVisualSymbolicExpressionTreeNode.SymbolicExpressionTreeNode.IterateNodesPostfix().ToArray();
+        var nodes = symbolicExpressionTreeChart.Tree.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+        var fragments = _selectedVisualSymbolicExpressionTreeNode.SymbolicExpressionTreeNode.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
         int index = SymbolicExpressionTreeMatching.FindMatch(nodes, fragments, similarityModeSelector.SelectedIndex);
         if (index != -1) {
-          _selectedVisualSymbolicExpressionTreeNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(nodes[index + fragments.Count() - 1]);
+          _selectedVisualSymbolicExpressionTreeNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(nodes[index + fragments.Count - 1]);
           var subtree = _selectedVisualSymbolicExpressionTreeNode.SymbolicExpressionTreeNode;
           foreach (var visualNode in subtree.IterateNodesPostfix().Select(node => symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node))) {
@@ -104,18 +105,9 @@
         }
       }
-      // the cutpoint index represents the index of the node/subtree (when the tree is enumerated in postfix order) 
-      // that was changed (by mutation) or received from a parent (by crossover)
-      if (visualGenealogyGraphNode.Data.CutpointIndex != -1) {
-        var gNode = visualGenealogyGraphNode.Data;
-        var symbExprTree = gNode.Data as ISymbolicExpressionTree;
-        if (symbExprTree == null) return;
-        var nodes = symbExprTree.IterateNodesPostfix();
-        var fragment = nodes.ElementAt(gNode.CutpointIndex);
-        if (fragment != null) foreach (var node in fragment.IterateNodesPostfix()) {
-            var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
-            visualNode.FillColor = Color.LightPink;
-          }
-        symbolicExpressionTreeChart.Repaint();
-      }
+      // what's left to be done here is to:
+      // - get the symbolic expression tree 
+      // - get the corresponding fragment
+      // - for all symbolic expression tree nodes in the fragment, colorize the corresponding visual nodes
+      // - repaint the tree
     }
 
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreeFragmentsAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreeFragmentsAnalyzer.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreeFragmentsAnalyzer.cs	(revision 7792)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -162,6 +163,5 @@
         ResultCollection results = ResultsParameter.ActualValue;
         if (FragmentStatistics == null) {
-          FragmentStatisticsParameter.ActualValue = new DataTable("Fragment Statistics",
-                                                                  "Statistical measurements of fragments aggregated over the whole population");
+          FragmentStatisticsParameter.ActualValue = new DataTable("Fragment Statistics", "Statistical measurements of fragments aggregated over the whole population");
           FragmentStatistics.VisualProperties.YAxisTitle = "Fragment length/Similarities";
           results.Add(new Result("Fragment Statistics", FragmentStatistics));
@@ -177,20 +177,21 @@
         var trees = (from s in gScope.SubScopes select s.Variables.First().Value as ISymbolicExpressionTree).ToList();
         foreach (var tree in trees.Where(x => GlobalTraceMap.ContainsKey(x))) {
-          if (GlobalTraceMap[tree].Count == 2) {
-            var fragment = tree.IterateNodes().ElementAt(((IntValue)GlobalFragmentMap[tree]).Value);
-            if (fragment != null) {
-              parents.AddRange(GlobalTraceMap[tree].Cast<ISymbolicExpressionTree>());
-              fragments.Add(fragment);
-            } else { // "intermediate crossovers" (immediately followed by mutation)
-              var parent0 = (ISymbolicExpressionTree)GlobalTraceMap[tree][0];
-              if (GlobalTraceMap.ContainsKey(parent0)) {
-                var p = (ISymbolicExpressionTree)GlobalTraceMap[parent0][0];
-                fragment = parent0.IterateNodes().ElementAt(((IntValue)GlobalFragmentMap[parent0]).Value);
-                if (fragment != null) {
-                  parents.AddRange(GlobalTraceMap[parent0].Cast<ISymbolicExpressionTree>());
-                  fragments.Add(fragment);
-                }
-              }
-            }
+          if (GlobalTraceMap[tree].Count == 2) { // crossover 
+            var nodes = tree.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+            var index = ((IntValue)GlobalFragmentMap[tree]).Value;
+            var fragment = nodes[index];
+            if (fragment == null) throw new ArgumentException("Fragment not found");
+            parents.AddRange(GlobalTraceMap[tree].Cast<ISymbolicExpressionTree>());
+            fragments.Add(fragment);
+          } else { // crossover followed by mutation
+            // maybe mutation fragments should be also taken into account?
+            var parent0 = (ISymbolicExpressionTree)GlobalTraceMap[tree][0];
+            if (!GlobalFragmentMap.ContainsKey(parent0)) throw new ArgumentException("Fragment not found");
+            var nodes = parent0.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+            var index = ((IntValue)GlobalFragmentMap[parent0]).Value;
+            var fragment = nodes[index];
+            fragments.Add(fragment);
+            if (!GlobalTraceMap.ContainsKey(parent0)) throw new ArgumentException("Parent information not found");
+            parents.AddRange(GlobalTraceMap[parent0].Cast<ISymbolicExpressionTree>());
           }
         }
@@ -201,12 +202,9 @@
         double a3 = parents.Average(x => x.Length);
         double s1 = CalculateSimilarity(fragments, (int)SymbolicExpressionTreeMatching.SimilarityLevel.Exact);
-        //double s2 = CalculateSimilarity(fragments, (int)SymbolicExpressionTreeMatching.SimilarityLevel.High);
-        //double s3 = CalculateSimilarity(fragments, (int)SymbolicExpressionTreeMatching.SimilarityLevel.Relaxed);
 
         #region Table data
         // fragments
         if (!FragmentStatistics.Rows.ContainsKey("Average fragment length")) {
-          DataRow row = new DataRow("Average fragment length", "");
-          row.VisualProperties.StartIndexZero = true;
+          var row = new DataRow("Average fragment length", "") { VisualProperties = { StartIndexZero = true } };
           FragmentStatistics.Rows.Add(row);
         }
@@ -214,6 +212,5 @@
         // child trees
         if (!FragmentStatistics.Rows.ContainsKey("Average child length")) {
-          DataRow row = new DataRow("Average child length", "");
-          row.VisualProperties.StartIndexZero = true;
+          var row = new DataRow("Average child length", "") { VisualProperties = { StartIndexZero = true } };
           FragmentStatistics.Rows.Add(row);
         }
@@ -221,6 +218,5 @@
         // parents
         if (!FragmentStatistics.Rows.ContainsKey("Average parent length")) {
-          DataRow row = new DataRow("Average parent length", "");
-          row.VisualProperties.StartIndexZero = true;
+          var row = new DataRow("Average parent length", "") { VisualProperties = { StartIndexZero = true } };
           FragmentStatistics.Rows.Add(row);
         }
@@ -228,23 +224,8 @@
         // exact similarity
         if (!FragmentStatistics.Rows.ContainsKey("Similarity (exact)")) {
-          DataRow row = new DataRow("Similarity (exact)", "");
-          row.VisualProperties.StartIndexZero = true;
+          var row = new DataRow("Similarity (exact)", "") { VisualProperties = { StartIndexZero = true } };
           FragmentStatistics.Rows.Add(row);
         }
         FragmentStatistics.Rows["Similarity (exact)"].Values.Add(s1);
-        // high similarity
-        //if (!FragmentStatistics.Rows.ContainsKey("Similarity (high)")) {
-        //  DataRow row = new DataRow("Similarity (high)", "");
-        //  row.VisualProperties.StartIndexZero = true;
-        //  FragmentStatistics.Rows.Add(row);
-        //}
-        //FragmentStatistics.Rows["Similarity (high)"].Values.Add(s2);
-        //// relaxed similarity
-        //if (!FragmentStatistics.Rows.ContainsKey("Similarity (relaxed)")) {
-        //  DataRow row = new DataRow("Similarity (relaxed)", "");
-        //  row.VisualProperties.StartIndexZero = true;
-        //  FragmentStatistics.Rows.Add(row);
-        //}
-        //FragmentStatistics.Rows["Similarity (relaxed)"].Values.Add(s3);
         #endregion
 
@@ -252,6 +233,8 @@
 
         // clear the global maps to save memory
-        GlobalCloneMap.Clear();
-        GlobalTraceMap.Clear();
+        if (this.Successor == null || !(this.Successor is SymbolicExpressionTreeGenealogyAnalyzer)) {
+          GlobalCloneMap.Clear();
+          GlobalTraceMap.Clear();
+        }
         GlobalFragmentMap.Clear();
       }
@@ -315,7 +298,13 @@
     #endregion
 
+    /// <summary>
+    /// Provide a measure of how similar the fragments that get passed by crossover from one generation to the next are. 
+    /// </summary>
+    /// <param name="fragments">The symbolic expression tree fragments</param>
+    /// <param name="mode">The similarity mode (0 - exact, 1 - high, 2 - relaxed)</param>
+    /// <returns>The average number of similar fragments</returns>
     private double CalculateSimilarity(List<ISymbolicExpressionTreeNode> fragments, int mode) {
-      bool[] visited = new bool[fragments.Count];
-      int count = 0;
+      var visited = new bool[fragments.Count];
+      int groups = 0;
       for (int i = 0; i != fragments.Count - 1; ++i) {
         if (visited[i]) continue;
@@ -324,7 +313,7 @@
           if (fragments[i].IsSimilarTo(fragments[j], mode)) visited[j] = true;
         }
-        ++count;
-      }
-      return (double)fragments.Count / count;
+        ++groups;
+      }
+      return (double)fragments.Count / groups;
     }
     #endregion
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreeGenealogyAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreeGenealogyAnalyzer.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreeGenealogyAnalyzer.cs	(revision 7792)
@@ -21,5 +21,4 @@
 
 using System;
-using System.Collections.Generic;
 using System.Drawing;
 using System.Globalization;
@@ -219,5 +218,4 @@
           Results.Add(new Result(PopulationGraphResultParameterName, PopulationGraphResultParameterDescription, graph));
         } else {
-          //graph = (SymbolicExpressionTreeGenealogyGraph)Results[PopulationGraphResultParameterName].Value;
           graph = (SymbolicExpressionTreeGenealogyGraph)(Results[PopulationGraphResultParameterName].Value);
         }
@@ -233,5 +231,6 @@
         string label;
         if (generation == 0) {
-          // at generation 0 no trace map is present (since no reproduction has taken place yet), so we only add the initial trees as nodes in the genealogy graph
+          // at generation 0 no trace map is present (since no reproduction has taken place yet), 
+          // so we only add the initial individuals as nodes in the genealogy graph
           for (int i = 0; i != qualities.Count; ++i) {
             var tree = qualities.ElementAt(i).Key;
@@ -246,5 +245,6 @@
           var child = qualities.ElementAt(i).Key;
           label = (generation * qualities.Count + i + 1).ToString(CultureInfo.InvariantCulture);
-          if (!graph.HasNode(child)) graph.AddNode(child, qualities[child], label, generation, i < Elites.Value);
+          if (!graph.HasNode(child))
+            graph.AddNode(child, qualities[child], label, generation, i < Elites.Value);
           if (!GlobalTraceMap.ContainsKey(child)) continue;
           var parents = GlobalTraceMap[child];
@@ -264,6 +264,8 @@
 
         // clear trace and clone maps in preparation for the next generation
-        GlobalTraceMap.Clear();
-        GlobalCloneMap.Clear();
+        if (this.Successor == null || !(this.Successor is SymbolicExpressionTreeFragmentsAnalyzer)) {
+          GlobalTraceMap.Clear();
+          GlobalCloneMap.Clear();
+        }
 
         #region end of the run (code for writing results to dot files)
@@ -315,5 +317,5 @@
     }
 
-  
+
 
     private double Evaluate(ISymbolicExpressionTree tree) {
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/GenealogyGraph.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/GenealogyGraph.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/GenealogyGraph.cs	(revision 7792)
@@ -95,7 +95,7 @@
     /// <param name="rank">The node rank</param>
     /// <param name="elite">Specifies if this node is an elite</param>
-    public void AddNode(T t, double quality = 0.0, string label = "", double rank = 0, bool elite = false, int cutIndex = -1) {
+    public void AddNode(T t, double quality = 0.0, string label = "", double rank = 0, bool elite = false) {
       if (HasNode(t)) return;
-      _dictionary[t] = new GenealogyGraphNode { Data = t, Quality = quality, Label = label, IsElite = elite, Rank = rank, CutpointIndex = cutIndex };
+      _dictionary[t] = new GenealogyGraphNode { Data = t, Quality = quality, Label = label, IsElite = elite, Rank = rank };
     }
 
@@ -103,9 +103,9 @@
     ///  more of a low level method to minimize memory usage when creating and returning subgraphs
     /// </summary>
-    /// <param name="n">The node to be added</param>
-    public void AddNode(GenealogyGraphNode n) {
-      var t = (T)n.Data;
+    /// <param name="node">The node to be added</param>
+    public void AddNode(GenealogyGraphNode node) {
+      var t = (T)node.Data;
       if (HasNode(t)) return;
-      _dictionary[t] = n;
+      _dictionary[t] = node;
     }
 
@@ -116,20 +116,20 @@
     public void RemoveNode(T t) {
       if (!_dictionary.ContainsKey(t)) return;
-      GenealogyGraphNode n = _dictionary[t];
-      if (n.InEdges != null) {
-        foreach (var e in n.InEdges.Where(e => e.Target.OutEdges != null)) {
-          e.Target.OutEdges.RemoveAll(arc => arc.Target == n);
+      var node = _dictionary[t];
+      if (node.InEdges != null) {
+        foreach (var e in node.InEdges.Where(e => e.Target.OutEdges != null)) {
+          e.Target.OutEdges.RemoveAll(arc => arc.Target == node);
           if (!e.Target.OutEdges.Any())
             e.Target.OutEdges = null; // set to null to be a little more memory efficient
         }
-        n.InEdges = null;
-      }
-      if (n.OutEdges != null) {
-        foreach (var e in n.OutEdges.Where(e => e.Target.InEdges != null)) {
-          e.Target.InEdges.RemoveAll(arc => arc.Target == n);
+        node.InEdges = null;
+      }
+      if (node.OutEdges != null) {
+        foreach (var e in node.OutEdges.Where(e => e.Target.InEdges != null)) {
+          e.Target.InEdges.RemoveAll(arc => arc.Target == node);
           if (!e.Target.InEdges.Any())
             e.Target.InEdges = null; // set to null to be a little more memory efficient
         }
-        n.OutEdges = null;
+        node.OutEdges = null;
       }
       _dictionary.Remove(t);
@@ -145,6 +145,5 @@
     /// <param name="a"></param>
     /// <param name="b"></param>
-    /// <param name="label"></param>
-    public void AddArc(T a, T b, int opType = 0) {
+    public void AddArc(T a, T b) {
       GenealogyGraphNode src, dest;
       if (!HasNode(a)) {
@@ -161,9 +160,9 @@
       }
       // add forward and reverse arcs
-      src.AddForwardArc(dest, opType);
-      dest.AddReverseArc(src, opType);
-    }
-
-    public void AddArcs(T[] a, T b, int opType = 0) {
+      src.AddForwardArc(dest);
+      dest.AddReverseArc(src);
+    }
+
+    public void AddArcs(T[] a, T b) {
       GenealogyGraphNode src, dest;
       if (!HasNode(b)) {
@@ -180,6 +179,6 @@
           src = _dictionary[o];
         }
-        src.AddForwardArc(dest, opType);
-        dest.AddReverseArc(src, opType);
+        src.AddForwardArc(dest);
+        dest.AddReverseArc(src);
       }
     }
@@ -193,5 +192,4 @@
     public double Quality { get; set; }
     public double Rank { get; set; }
-    public int CutpointIndex { get; set; }
     public List<GenealogyGraphArc> InEdges { get; set; }
     public List<GenealogyGraphArc> OutEdges { get; set; }
@@ -210,11 +208,10 @@
       InEdges = node.InEdges;
       OutEdges = node.OutEdges;
-      CutpointIndex = node.CutpointIndex;
-    }
-
-    /// <summary>
-    /// Returns all the ancestors of the current node
-    /// </summary>
-    /// <returns></returns>
+    }
+
+    /// <summary>
+    /// Performs an upward-breath-traversal of the genealogy graph using the nodes InEdges
+    /// </summary>
+    /// <returns>All the ancestors of the current node</returns>
     public IEnumerable<GenealogyGraphNode> Ancestors() {
       var nodes = new HashSet<GenealogyGraphNode> { this };
@@ -236,7 +233,7 @@
 
     /// <summary>
-    /// Returns all the descendants of the current node (identical to above method except for using the OutEdges)
-    /// </summary>
-    /// <returns></returns>
+    /// 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<GenealogyGraphNode> Descendants() {
       var nodes = new HashSet<GenealogyGraphNode> { this };
@@ -257,12 +254,12 @@
     }
 
-    public void AddForwardArc(GenealogyGraphNode target, int opType) {
-      var e = new GenealogyGraphArc { Target = target, OperatorType = opType };
+    public void AddForwardArc(GenealogyGraphNode target) {
+      var e = new GenealogyGraphArc { Target = target };
       if (OutEdges == null) OutEdges = new List<GenealogyGraphArc> { e };
       else OutEdges.Add(e);
     }
 
-    public void AddReverseArc(GenealogyGraphNode target, int opType) {
-      var e = new GenealogyGraphArc { Target = target, OperatorType = opType };
+    public void AddReverseArc(GenealogyGraphNode target) {
+      var e = new GenealogyGraphArc { Target = target };
       if (InEdges == null) InEdges = new List<GenealogyGraphArc> { e };
       else InEdges.Add(e);
@@ -289,8 +286,4 @@
   public class GenealogyGraphArc {
     public GenealogyGraphNode Target { get; set; }
-    // OperationType is an identifier for the genetic operation (mutation, crossover) that a graph arc will represent 
-    // So basically it describes which operator was applied to an individual/graph node (the one emitting the arc), 
-    // while Target represents the end result of that operator (node ==GeneticOperation==> Target)
-    public int OperatorType { get; set; }
     // these two fields are not used, but they might be useful later 
     public string Label { get; set; } // might be useful later
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Interfaces/IGenealogyGraph.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Interfaces/IGenealogyGraph.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Interfaces/IGenealogyGraph.cs	(revision 7792)
@@ -30,10 +30,10 @@
     bool Any(Func<KeyValuePair<T, GenealogyGraphNode>, bool> predicate); // graph contains any nodes matching the given predicate?
     void Clear(); // clear graph
-    void AddNode(T t, double quality = 0.0, string label = "", double rank = 0, bool elite = false, int cutIndex = -1);
+    void AddNode(T t, double quality = 0.0, string label = "", double rank = 0, bool elite = false);
     void RemoveNode(T t); // remove node if contained in the graph
     GenealogyGraphNode GetNode(T t); // return node corresponding to object t, or null
     // arc operation
-    void AddArc(T source, T target, int opType = 0);
-    void AddArcs(T[] a, T b, int opType = 0);
+    void AddArc(T source, T target);
+    void AddArcs(T[] a, T b);
   }
 }
Index: /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Selection/3.3/Plugin.cs
===================================================================
--- /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Selection/3.3/Plugin.cs	(revision 7791)
+++ /branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Selection/3.3/Plugin.cs	(revision 7792)
@@ -26,5 +26,5 @@
   /// Plugin class for HeuristicLab.Selection plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Selection", "3.3.6.7785")]
+  [Plugin("HeuristicLab.Selection", "3.3.6.7788")]
   [PluginFile("HeuristicLab.Selection-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
