Changeset 11233

Timestamp:

07/30/14 01:41:54 (10 years ago)

Author:

bburlacu

Message:

#1772: Worked towards integrating the new graph api with the tracking operators.

Location:

branches/HeuristicLab.EvolutionTracking

Files:

• HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs (modified) (6 diffs)
• HeuristicLab.EvolutionTracking/3.4/DirectedGraph (moved) (moved from branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/DirectedGraph)
• HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Arc.cs (modified) (1 diff)
• HeuristicLab.EvolutionTracking/3.4/DirectedGraph/DirectedGraph.cs (modified) (4 diffs)
• HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Interfaces/IArc.cs (modified) (1 diff)
• HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Interfaces/IDirectedGraph.cs (modified) (1 diff)
• HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Interfaces/IVertex.cs (modified) (1 diff)
• HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Vertex.cs (modified) (4 diffs)
• HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraph.cs (modified) (5 diffs)
• HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraphArc.cs (modified) (3 diffs)
• HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraphNode.cs (modified) (4 diffs)
• HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraph.cs (modified) (1 diff)
• HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphArc.cs (modified) (1 diff)
• HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphNode.cs (modified) (2 diffs)
• HeuristicLab.EvolutionTracking/3.4/Operators/BeforeCrossoverOperator.cs (modified) (2 diffs)
• HeuristicLab.EvolutionTracking/3.4/Operators/BeforeManipulatorOperator.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/SymboldDataAnalysisGenealogyView.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterCrossoverOperator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterManipulatorOperator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionBeforeCrossoverOperator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionBeforeManipulatorOperator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionTracing.cs (modified) (6 diffs)

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs

@@ -20 +20 @@
 #endregion
 
+using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Analysis;
@@ -268 +269 @@
         #region add elite in the graph and connect it with the previous elite
         if (elite != null) {
-          var prevVertex = (IGenealogyGraphNode<T>)GenealogyGraph.GetVertex(elite);
+          var prevVertex = (IGenealogyGraphNode<T>)GenealogyGraph.GetByContent(elite);
           prevVertex.IsElite = true; // mark elites in the graph retroactively
 
           var clone = (T)elite.Clone();
 
-          var vertex = new GenealogyGraphNode<T>(prevVertex.Content) {
+          var v = new GenealogyGraphNode<T>(prevVertex.Content) {
             Rank = generation,
             Quality = prevVertex.Quality,
@@ -279 +280 @@
           };
 
-          prevVertex.Content = clone;
+          var w = new GenealogyGraphNode<T>(clone) {
+            Rank = generation - 1,
+            Quality = prevVertex.Quality,
+            IsElite = true
+          };
+
+          // replace previous elite with vertex w 
+          List<IGenealogyGraphNode<T>> parents = null;
+          object data = null;
+          if (prevVertex.InArcs.Any()) {
+            data = prevVertex.InArcs.Last().Data;
+            parents = prevVertex.InArcs.Select(x => (IGenealogyGraphNode<T>)x.Source).ToList();
+            //            v.InArcs.Last().Data = prevVertex.InArcs.Last().Data; // save the fragment in case there is one
+            //            var p = prevVertex.InArcs.First().Source;
+            //            GenealogyGraph.AddArc(p, w);
+          }
+          GenealogyGraph.RemoveVertex(prevVertex);
+          GenealogyGraph.AddVertex(w);
+          GenealogyGraph.AddVertex(v);
+          GenealogyGraph.AddArc(w, v); // connect current elite with previous elite
+
+          v.InArcs.Last().Data = data;
+          if (parents != null) {
+            foreach (var p in parents)
+              GenealogyGraph.AddArc(p, w);
+          }
+
           // inject the graph node unique id to the scope
-          ExecutionContext.Scope.SubScopes[index].Variables["Id"].Value = new StringValue(vertex.Id);
-          GenealogyGraph.AddVertex(vertex);
-          GenealogyGraph.AddArc(prevVertex, vertex); // connect current elite with previous elite
-
-          if (prevVertex.InArcs.Any()) {
-            vertex.InArcs.Last().Data = prevVertex.InArcs.Last().Data; // save the fragment in case there is one
-          }
+          ExecutionContext.Scope.SubScopes[index].Variables["Id"].Value = new StringValue(v.Id);
         }
         #endregion
@@ -295 +316 @@
       // update qualities
       for (int i = 0; i < population.Length; ++i) {
-        var vertex = (IGenealogyGraphNode)GenealogyGraph.GetVertex(population[i]);
+        var vertex = (IGenealogyGraphNode)GenealogyGraph.GetByContent(population[i]);
         vertex.Quality = qualities[i].Value;
       }
@@ -301 +322 @@
       // remove extra graph nodes (added by the instrumented operators in the case of offspring selection)
       var discardedOffspring = GenealogyGraph.Ranks[generation].Select(x => (T)x.Content).Except(population).ToList();
-      foreach (var vertex in discardedOffspring.Select(individual => GenealogyGraph.GetVertex(individual))) {
+      foreach (var vertex in discardedOffspring.Select(individual => GenealogyGraph.GetByContent(individual))) {
         GenealogyGraph.RemoveVertex(vertex);
       }
@@ -313 +334 @@
       // compute the weight of each genealogy graph node as the ratio (produced offspring) / (surviving offspring)
       foreach (var ind in population) {
-        var v = (IGenealogyGraphNode)GenealogyGraph.GetVertex(ind);
+        var v = (IGenealogyGraphNode)GenealogyGraph.GetByContent(ind);
         foreach (var p in v.Parents)
           p.Weight++;

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Arc.cs

@@ -25 +25 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+namespace HeuristicLab.EvolutionTracking {
   /// <summary>
   /// An arc that can have a weight, a label, and a data object for holding additional info

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/DirectedGraph/DirectedGraph.cs

@@ -28 +28 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+namespace HeuristicLab.EvolutionTracking {
   [Item("DirectedGraph", "Generic class representing a directed graph with custom vertices and content")]
   [StorableClass]
@@ -94 +94 @@
       vertex.ArcAdded += OnArcAdded;
       vertex.ArcRemoved += OnArcRemoved;
-      OnVertexAdded(this, EventArgs.Empty);
     }
 
@@ -106 +105 @@
       vertex.ArcRemoved -= OnArcRemoved;
       vertex.Changed -= OnVertexChanged;
-      OnVertexRemoved(this, EventArgs.Empty);
     }
 
-    public IArc AddArc(IVertex source, IVertex target) {
+    public virtual IArc AddArc(IVertex source, IVertex target) {
       var arc = new Arc(source, target);
       AddArc(arc);
@@ -131 +129 @@
     }
 
-    public event EventHandler VertexAdded;
-    protected virtual void OnVertexAdded(object sender, EventArgs args) {
-      var added = VertexAdded;
-      if (added != null)
-        added(sender, args);
-    }
 
-    public event EventHandler VertexChanged;
-    protected virtual void OnVertexChanged(object sender, EventArgs args) {
-      var changed = VertexChanged;
-      if (changed != null)
-        changed(sender, args);
-    }
-
-    public event EventHandler VertexRemoved;
-    protected virtual void OnVertexRemoved(object sender, EventArgs args) {
-      var removed = VertexRemoved;
-      if (removed != null)
-        removed(sender, args);
-    }
+    protected virtual void OnVertexChanged(object sender, EventArgs args) { }
 
     protected virtual void OnArcAdded(object sender, EventArgs<IArc> args) {

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Interfaces/IArc.cs

@@ -23 +23 @@
 using HeuristicLab.Core;
 
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+namespace HeuristicLab.EvolutionTracking {
   public interface IArc : IItem {
     event EventHandler Changed; // generic event for when the label, weight or data were changed

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Interfaces/IDirectedGraph.cs

@@ -23 +23 @@
 using HeuristicLab.Core;
 
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+namespace HeuristicLab.EvolutionTracking {
   public interface IDirectedGraph : IItem {
     void Clear();

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Interfaces/IVertex.cs

@@ -25 +25 @@
 using HeuristicLab.Core;
 
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+namespace HeuristicLab.EvolutionTracking {
   public interface IVertex : IItem {
     event EventHandler Changed; // generic event for when the content, label or weight have changed

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/DirectedGraph/Vertex.cs

@@ -27 +27 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+namespace HeuristicLab.EvolutionTracking {
   [StorableClass]
   public class Vertex : Item, IVertex {
@@ -126 +126 @@
         if (outArcs == null)
           outArcs = new List<IArc>();
-        else if (outArcs.Contains(arc) || outArcs.Any(a => a.Target == arc.Target && a.Source == arc.Source))
+        else if (outArcs.Contains(arc) || outArcs.Any(a => a.Target == arc.Target))
           throw new InvalidOperationException("Arc already added.");
         outArcs.Add(arc);
@@ -132 +132 @@
         if (inArcs == null)
           inArcs = new List<IArc>();
-        else if (inArcs.Contains(arc) || inArcs.Any(a => a.Target == arc.Target && a.Source == arc.Source))
+        else if (inArcs.Contains(arc) || inArcs.Any(a => a.Source == arc.Source))
           throw new InvalidOperationException("Arc already added.");
         inArcs.Add(arc);
@@ -175 +175 @@
     }
 
+    public Vertex(object content) : base(content) { }
+
     [StorableConstructor]
     protected Vertex(bool deserializing) : base(deserializing) { }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraph.cs

@@ -32 +32 @@
   public class GenealogyGraph : DirectedGraph, IGenealogyGraph {
     [Storable]
+    private readonly Dictionary<object, IGenealogyGraphNode> contentMap;
+
+    [Storable]
+    private readonly Dictionary<string, IGenealogyGraphNode> idMap;
+
+    [Storable]
     private Dictionary<double, List<IGenealogyGraphNode>> ranks; // use a linked list for fast insertion/removal
     public Dictionary<double, List<IGenealogyGraphNode>> Ranks {
@@ -37 +43 @@
       set { ranks = value; }
     }
-    public new IEnumerable<IGenealogyGraphNode> Vertices {
-      get { return from n in base.Vertices select (IGenealogyGraphNode)n; }
-    }
 
     protected GenealogyGraph(GenealogyGraph original, Cloner cloner)
       : base(original, cloner) {
       Ranks = new Dictionary<double, List<IGenealogyGraphNode>>(original.Ranks);
-    }
+      contentMap = new Dictionary<object, IGenealogyGraphNode>(original.contentMap);
+      idMap = new Dictionary<string, IGenealogyGraphNode>(original.idMap);
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new GenealogyGraph(this, cloner);
     }
+
     [StorableConstructor]
     protected GenealogyGraph(bool deserializing) : base(deserializing) { }
     public GenealogyGraph() {
       Ranks = new Dictionary<double, List<IGenealogyGraphNode>>();
+      contentMap = new Dictionary<object, IGenealogyGraphNode>();
+      idMap = new Dictionary<string, IGenealogyGraphNode>();
+    }
+
+    public new IEnumerable<IGenealogyGraphNode> Vertices {
+      get { return from n in base.Vertices select (IGenealogyGraphNode)n; }
     }
 
     public override IArc AddArc(IVertex source, IVertex target) {
       var arc = new GenealogyGraphArc((IGenealogyGraphNode)source, (IGenealogyGraphNode)target);
-      source.AddForwardArc(arc);
-      target.AddReverseArc(arc);
+      source.AddArc(arc);
+      target.AddArc(arc);
       arcs.Add(arc);
       return arc;
@@ -68 +81 @@
         Ranks[node.Rank] = new List<IGenealogyGraphNode>();
       Ranks[node.Rank].Add(node);
-    }
+
+      if (contentMap.ContainsKey(node.Content))
+        throw new InvalidOperationException("Duplicate content is not allowed in the genealogy graph.");
+      contentMap[node.Content] = node;
+
+      if (idMap.ContainsKey(node.Id))
+        throw new InvalidOperationException("Duplicate content is not allowed in the genealogy graph.");
+      idMap[node.Id] = node;
+
+      vertex.Changed += OnVertexChanged;
+    }
+
     public override void RemoveVertex(IVertex vertex) {
       var node = (IGenealogyGraphNode)vertex;
+      contentMap.Remove(node.Content);
+      idMap.Remove(node.Id);
       if (Ranks.ContainsKey(node.Rank)) {
         Ranks[node.Rank].Remove(node);
@@ -76 +102 @@
       base.RemoveVertex(vertex);
     }
+
+    public IGenealogyGraphNode GetByContent(object content) {
+      IGenealogyGraphNode result;
+      contentMap.TryGetValue(content, out result);
+      return result;
+    }
+
+    public IGenealogyGraphNode GetById(string id) {
+      IGenealogyGraphNode result;
+      idMap.TryGetValue(id, out result);
+      return result;
+    }
+
+    public bool Contains(object content) {
+      return contentMap.ContainsKey(content);
+    }
+
     public event EventHandler GraphUpdated;
     private void OnGraphUpdated(object sender, EventArgs args) {
@@ -86 +129 @@
       ranks.Clear();
     }
+
+    protected override void OnVertexChanged(object sender, EventArgs args) {
+      base.OnVertexChanged(sender, args);
+
+      var vertex = (IGenealogyGraphNode)sender;
+      if (!contentMap.ContainsKey(vertex.Content)) {
+        // vertex has received new content
+      }
+    }
   }
 
+  //  [StorableClass]
+  //  [Item("GenealogyGraph", "A class representing a genealogy graph")]
+  //  public class GenealogyGraph<T> : DirectedGraph, IGenealogyGraph<T> where T : class, IItem {
+  //    // members and properties
+  //    [Storable]
+  //    private Dictionary<double, List<IGenealogyGraphNode>> ranks;
+  //    public Dictionary<double, List<IGenealogyGraphNode>> Ranks {
+  //      get { return ranks; }
+  //      set { ranks = value; }
+  //    }
+  //    public new IEnumerable<IGenealogyGraphNode<T>> Vertices {
+  //      get { return from n in base.Vertices select (IGenealogyGraphNode<T>)n; }
+  //    }
+  //    // contructors
+  //    protected GenealogyGraph(GenealogyGraph<T> original, Cloner cloner)
+  //      : base(original, cloner) {
+  //    }
+  //    public override IDeepCloneable Clone(Cloner cloner) {
+  //      return new GenealogyGraph<T>(this, cloner);
+  //    }
+  //
+  //    [StorableConstructor]
+  //    protected GenealogyGraph(bool deserializing) : base(deserializing) { }
+  //    public GenealogyGraph() {
+  //      Ranks = new Dictionary<double, List<IGenealogyGraphNode>>();
+  //    }
+  //
+  //    // methods
+  //    public override void AddVertex(IVertex vertex) {
+  //      base.AddVertex(vertex);
+  //      var node = (IGenealogyGraphNode)vertex;
+  //      if (!Ranks.ContainsKey(node.Rank)) {
+  //        Ranks[node.Rank] = new List<IGenealogyGraphNode>();
+  //      }
+  //      Ranks[node.Rank].Add(node);
+  //    }
+  //
+  //    public override void RemoveVertex(IVertex vertex) {
+  //      var node = (IGenealogyGraphNode<T>)vertex;
+  //      if (Ranks.ContainsKey(node.Rank)) {
+  //        Ranks[node.Rank].Remove(node);
+  //      }
+  //      base.RemoveVertex(vertex);
+  //    }
+  //
+  //    public override IArc AddArc(IVertex source, IVertex target) {
+  //      var arc = new GenealogyGraphArc((IGenealogyGraphNode)source, (IGenealogyGraphNode)target);
+  //      source.AddArc(arc);
+  //      target.AddArc(arc);
+  //      arcs.Add(arc);
+  //      return arc;
+  //    }
+  //
+  //    IEnumerable<IGenealogyGraphNode> IGenealogyGraph.Vertices {
+  //      get { return Vertices; }
+  //    }
+  //
+  //    public IGenealogyGraphNode GetByContent(object content)
+  //    {
+  //      IGenealogyGraphNode result;
+  //      contentMap.
+  //    }
+  //
+  //    public event EventHandler GraphUpdated;
+  //    private void OnGraphUpdated(object sender, EventArgs args) {
+  //      var updated = GraphUpdated;
+  //      if (updated != null) updated(sender, args);
+  //    }
+  //  }
   [StorableClass]
-  [Item("GenealogyGraph", "A class representing a genealogy graph")]
-  public class GenealogyGraph<T> : DirectedGraph, IGenealogyGraph<T> where T : class, IItem {
-    // members and properties
-    [Storable]
-    private Dictionary<double, List<IGenealogyGraphNode>> ranks;
-    public Dictionary<double, List<IGenealogyGraphNode>> Ranks {
-      get { return ranks; }
-      set { ranks = value; }
-    }
+
+  [Item("GenealogyGraph", "A specialization of the genealogy graph with T as content for vertices")]
+  public class GenealogyGraph<T> : GenealogyGraph, IGenealogyGraph<T> where T : class, IItem {
     public new IEnumerable<IGenealogyGraphNode<T>> Vertices {
-      get { return from n in base.Vertices select (IGenealogyGraphNode<T>)n; }
-    }
-    // contructors
-    protected GenealogyGraph(GenealogyGraph<T> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new GenealogyGraph<T>(this, cloner);
-    }
-    [StorableConstructor]
-    protected GenealogyGraph(bool deserializing) : base(deserializing) { }
-    public GenealogyGraph() {
-      Ranks = new Dictionary<double, List<IGenealogyGraphNode>>();
-    }
-    // methods
-    public override void AddVertex(IVertex vertex) {
-      base.AddVertex(vertex);
-      var node = (IGenealogyGraphNode)vertex;
-      if (!Ranks.ContainsKey(node.Rank)) {
-        Ranks[node.Rank] = new List<IGenealogyGraphNode>();
-      }
-      Ranks[node.Rank].Add(node);
-    }
-    public override void RemoveVertex(IVertex vertex) {
-      var node = (IGenealogyGraphNode<T>)vertex;
-      if (Ranks.ContainsKey(node.Rank)) {
-        Ranks[node.Rank].Remove(node);
-      }
-      base.RemoveVertex(vertex);
-    }
-    public override IArc AddArc(IVertex source, IVertex target) {
-      var arc = new GenealogyGraphArc((IGenealogyGraphNode)source, (IGenealogyGraphNode)target);
-      source.AddForwardArc(arc);
-      target.AddReverseArc(arc);
-      arcs.Add(arc);
-      return arc;
-    }
-    IEnumerable<IGenealogyGraphNode> IGenealogyGraph.Vertices {
-      get { return Vertices; }
-    }
-    public event EventHandler GraphUpdated;
-    private void OnGraphUpdated(object sender, EventArgs args) {
-      var updated = GraphUpdated;
-      if (updated != null) updated(sender, args);
+      get { return base.Vertices.Cast<IGenealogyGraphNode<T>>(); }
     }
   }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraphArc.cs

@@ -33 +33 @@
       : base(original, cloner) { }
 
-    protected GenealogyGraphArc() { }
-
-    public GenealogyGraphArc(IGenealogyGraphNode source, IGenealogyGraphNode target, object data = null) {
-      Source = source;
-      Target = target;
-      Data = data;
+    public GenealogyGraphArc(IGenealogyGraphNode source, IGenealogyGraphNode target)
+      : base(source, target) {
     }
 
@@ -47 +43 @@
     public new IGenealogyGraphNode Source {
       get { return (IGenealogyGraphNode)base.Source; }
-      set { base.Source = value; }
     }
 
     public new IGenealogyGraphNode Target {
       get { return (IGenealogyGraphNode)base.Target; }
-      set { base.Target = value; }
     }
   }
@@ -63 +57 @@
     protected GenealogyGraphArc(GenealogyGraphArc<T> original, Cloner cloner)
       : base(original, cloner) {
-      Data = (T)original.Data;
+      Data = original.Data;
     }
 

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraphNode.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -39 +40 @@
     }
 
-    public GenealogyGraphNode() { }
-    public GenealogyGraphNode(object content) : base(content) { }
+    public GenealogyGraphNode(object content)
+      : base(content) {
+      Id = Guid.NewGuid().ToString();
+    }
 
     public new IEnumerable<IGenealogyGraphArc> InArcs {
       get { return base.InArcs.Cast<IGenealogyGraphArc>(); }
-      set { base.InArcs = value; }
     }
     public new IEnumerable<IGenealogyGraphArc> OutArcs {
       get { return base.OutArcs.Cast<IGenealogyGraphArc>(); }
-      set { base.OutArcs = value; }
     }
     public IEnumerable<IGenealogyGraphNode> Ancestors {
@@ -88 +89 @@
     }
     [Storable]
+    public string Id { get; private set; }
+
+    [Storable]
     private double rank;
     public double Rank {
@@ -124 +128 @@
     }
 
-    public GenealogyGraphNode() { }
     public GenealogyGraphNode(object content) : base(content) { }
 
     protected GenealogyGraphNode(GenealogyGraphNode<T> original, Cloner cloner)
       : base(original, cloner) {
+      // we do not clone the content
       Content = original.Content;
     }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraph.cs

@@ -27 +27 @@
     Dictionary<double, List<IGenealogyGraphNode>> Ranks { get; }
     new IEnumerable<IGenealogyGraphNode> Vertices { get; }
+    IGenealogyGraphNode GetByContent(object content);
+    IGenealogyGraphNode GetById(string id);
+    bool Contains(object content);
   }
 

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphArc.cs

@@ -20 +20 @@
 #endregion
 
-using HeuristicLab.Core;
-
 namespace HeuristicLab.EvolutionTracking {
   public interface IGenealogyGraphArc : IArc {
-    new IGenealogyGraphNode Source { get; set; }
-    new IGenealogyGraphNode Target { get; set; }
-  }
-
-  public interface IGenealogyGraphArc<T> : IGenealogyGraphArc where T : class, IItem {
-    new T Data { get; set; }
+    new IGenealogyGraphNode Source { get; }
+    new IGenealogyGraphNode Target { get; }
   }
 }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphNode.cs

@@ -28 +28 @@
     double Quality { get; set; }
     bool IsElite { get; set; }
+    string Id { get; }
 
     IEnumerable<IGenealogyGraphNode> Parents { get; }
@@ -33 +34 @@
     IEnumerable<IGenealogyGraphNode> Ancestors { get; }
     IEnumerable<IGenealogyGraphNode> Descendants { get; }
-    new IEnumerable<IGenealogyGraphArc> InArcs { get; set; }
-    new IEnumerable<IGenealogyGraphArc> OutArcs { get; set; }
+    new IEnumerable<IGenealogyGraphArc> InArcs { get; }
+    new IEnumerable<IGenealogyGraphArc> OutArcs { get; }
   }
 

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/BeforeCrossoverOperator.cs

@@ -76 +76 @@
 
       var subScopes = ExecutionContext.Scope.SubScopes;
-      var parentVertices = subScopes.Select(x => (GenealogyGraphNode<T>)GenealogyGraph.GetVertex(getScopeId(x))).ToList();
+      var parentVertices = subScopes.Select(x => (GenealogyGraphNode<T>)GenealogyGraph.GetById(getScopeId(x))).ToList();
 
       var parents = ParentsParameter.ActualValue.ToList();
@@ -84 +84 @@
       GenealogyGraph.AddVertex(childVertex);
 
-      foreach (var parentVertex in parentVertices) {
+      foreach (var parentVertex in parentVertices.Distinct()) {
         GenealogyGraph.AddArc(parentVertex, childVertex);
       }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/BeforeManipulatorOperator.cs

@@ -20 +20 @@
 #endregion
 
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -39 +38 @@
       : base(original, cloner) {
     }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new BeforeManipulatorOperator<T>(this, cloner);
     }
+
     [StorableConstructor]
     protected BeforeManipulatorOperator(bool deserializing) : base(deserializing) { }
@@ -51 +52 @@
     public override IOperation Apply() {
       // since mutation always takes place after crossover, the vertex for the current child is already in the tree
-      var v = (IGenealogyGraphNode<T>)GenealogyGraph.GetVertex(ChildParameter.ActualValue);
+      var v = (IGenealogyGraphNode<T>)GenealogyGraph.GetByContent(ChildParameter.ActualValue);
       var clone = (T)ChildParameter.ActualValue.Clone();
 
       var c = new GenealogyGraphNode<T>(clone) { Rank = v.Rank - 0.5 };
 
-      foreach (var a in v.InArcs) {
-        a.Target = c;
-        c.AddReverseArc(a);
+      foreach (var arc in v.InArcs) {
+        var p = arc.Source;
+        GenealogyGraph.RemoveArc(arc);
+        GenealogyGraph.AddArc(new GenealogyGraphArc(p, c));
       }
 
-      v.InArcs = Enumerable.Empty<IGenealogyGraphArc>();
+      //      foreach (var a in v.InArcs) {
+      //        a.Target = c;
+      //        c.AddReverseArc(a);
+      //      }
+
+      //      v.InArcs = Enumerable.Empty<IGenealogyGraphArc>();
 
       GenealogyGraph.AddVertex(c);

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/SymboldDataAnalysisGenealogyView.cs

@@ -109 +109 @@
         var matchingTrees = trees.Where(x => x.Root.ContainsSubtree(subtree, comparer));
 
-        var matchingVertices = matchingTrees.Select(x => Content.GetVertex(x)).Cast<IGenealogyGraphNode<ISymbolicExpressionTree>>();
+        var matchingVertices = matchingTrees.Select(x => Content.GetByContent(x)).Cast<IGenealogyGraphNode<ISymbolicExpressionTree>>();
         graphChart_highlightMatchingVertices(matchingVertices);
       }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -176 +176 @@
     <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectivePruningAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisGenealogyAnalyzer.cs" />
-    <Compile Include="Analyzers\SymbolicDataAnalysisPopulationDiversityAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs" />
@@ -190 +189 @@
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="DirectedGraph\Arc.cs" />
-    <Compile Include="DirectedGraph\DirectedGraph.cs" />
-    <Compile Include="DirectedGraph\Interfaces\IArc.cs" />
-    <Compile Include="DirectedGraph\Interfaces\IDirectedGraph.cs" />
-    <Compile Include="DirectedGraph\Interfaces\IVertex.cs" />
-    <Compile Include="DirectedGraph\Vertex.cs" />
     <Compile Include="Interfaces\IModelBacktransformator.cs" />
     <Compile Include="Interfaces\IDistanceCalculator.cs" />
@@ -213 +206 @@
     <Compile Include="SlidingWindow\SlidingWindowQualitiesAnalyzer.cs" />
     <Compile Include="SlidingWindow\SlidingWindowVisualizer.cs" />
-    <Compile Include="SymbolGraph\FPGraph.cs" />
-    <Compile Include="SymbolGraph\SymbolGraph.cs" />
     <Compile Include="SymbolicDataAnalysisExpressionPruningOperator.cs" />
     <Compile Include="SymbolicDataAnalysisExpressionTreeSimilarityCalculator.cs" />

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

@@ -235 +235 @@
       Operators.Add(new SingleObjectivePopulationDiversityAnalyzer());
       Operators.Add(new BottomUpSimilarityCalculator());
+      Operators.Add(new SymbolicDataAnalysisGenealogyAnalyzer());
       ParameterizeOperators();
     }
@@ -361 +362 @@
         op.SimilarityCalculator = operators.OfType<BottomUpSimilarityCalculator>().SingleOrDefault();
       }
+      // add tracking analyzer
+      foreach (var op in operators.OfType<SymbolicDataAnalysisGenealogyAnalyzer>()) {
+        op.BeforeCrossoverOperatorParameter.ActualValue = new SymbolicDataAnalysisExpressionBeforeCrossoverOperator();
+        op.AfterCrossoverOperatorParameter.ActualValue = new SymbolicDataAnalysisExpressionAfterCrossoverOperator();
+        op.BeforeManipulatorOperatorParameter.ActualValue = new SymbolicDataAnalysisExpressionBeforeManipulatorOperator();
+        op.AfterManipulatorOperatorParameter.ActualValue = new SymbolicDataAnalysisExpressionAfterManipulatorOperator();
+        // get crossover parameter names
+        var crossover = operators.OfType<ISymbolicExpressionTreeCrossover>().FirstOrDefault();
+        if (crossover != null) {
+          op.BeforeCrossoverOperator.ParentsParameter.ActualName = crossover.ParentsParameter.Name;
+          op.AfterCrossoverOperator.ParentsParameter.ActualName = crossover.ParentsParameter.Name;
+          op.BeforeCrossoverOperator.ChildParameter.ActualName = crossover.ChildParameter.Name;
+          op.AfterCrossoverOperator.ChildParameter.ActualName = crossover.ChildParameter.Name;
+        }
+        // get manipulator parameter names
+        var manipulator = operators.OfType<ISymbolicExpressionTreeManipulator>().FirstOrDefault();
+        if (manipulator != null) {
+          op.BeforeManipulatorOperator.ChildParameter.ActualName = manipulator.SymbolicExpressionTreeParameter.Name;
+          op.AfterManipulatorOperator.ChildParameter.ActualName = manipulator.SymbolicExpressionTreeParameter.Name;
+        }
+        var creator = operators.OfType<ISymbolicExpressionTreeCreator>().FirstOrDefault();
+        if (creator != null) {
+          op.PopulationParameter.ActualName = creator.SymbolicExpressionTreeParameter.ActualName;
+        }
+      }
     }
 

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterCrossoverOperator.cs

@@ -30 +30 @@
   public class SymbolicDataAnalysisExpressionAfterCrossoverOperator : AfterCrossoverOperator<ISymbolicExpressionTree> {
     public override IOperation Apply() {
-      var childVertex = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetVertex(ChildParameter.ActualValue);
+      var childVertex = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetByContent(ChildParameter.ActualValue);
       var arcs = childVertex.InArcs.ToList();
       var nodes0 = (List<ISymbolicExpressionTreeNode>)arcs[0].Data;

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterManipulatorOperator.cs

@@ -40 +40 @@
 
     public override IOperation Apply() {
-      var vChild = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetVertex(ChildParameter.ActualValue);
+      var vChild = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetByContent(ChildParameter.ActualValue);
       var nodesBefore = (List<ISymbolicExpressionTreeNode>)vChild.InArcs.First().Data;
       var nodesAfter = ChildParameter.ActualValue.IterateNodesPrefix().ToList();

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionBeforeCrossoverOperator.cs

@@ -30 +30 @@
       var result = base.Apply(); // the base operator will add the child to the graph before the actual crossover operation takes place
       var parents = ParentsParameter.ActualValue.ToList();
-      var childVertex = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetVertex(parents[0]); // use the parent since it is actually the child before crossover (and the ChildParameter doesn't have a value yet)
+      var childVertex = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetByContent(parents[0]); // use the parent since it is actually the child before crossover (and the ChildParameter doesn't have a value yet)
       var arcs = childVertex.InArcs.ToList();
 

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionBeforeManipulatorOperator.cs

@@ -30 +30 @@
       var result = base.Apply(); // add the vertex in the genealogy graph
 
-      var vChild = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetVertex(ChildParameter.ActualValue);
+      var vChild = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetByContent(ChildParameter.ActualValue);
       var vClone = vChild.Parents.Last();
       vChild.InArcs.First().Data = vClone.Content.IterateNodesPrefix().ToList();

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionTracing.cs

@@ -30 +30 @@
   public static class SymbolicDataAnalysisExpressionTracing {
     public static FragmentGraph TraceSubtree(IGenealogyGraphNode<ISymbolicExpressionTree> graphNode, int subtreeIndex) {
-      var graph = new FragmentGraph { AllowDuplicateContent = true };
+      var graph = new FragmentGraph();
       var nodes = Trace(graphNode, subtreeIndex);
       foreach (var n in nodes) {
@@ -51 +51 @@
       while (true) {
         if (!node.Parents.Any()) {
-          var fragmentNode = new FragmentNode {
-            Content = node,
+          var fragmentNode = new FragmentNode(node) {
             SubtreeIndex = index,
           };
           if (parent != null) {
             var arc = new Arc(parent, fragmentNode);
-            parent.AddForwardArc(arc);
-            fragmentNode.AddReverseArc(arc);
+            parent.AddArc(arc);
+            fragmentNode.AddArc(arc);
+
+            //            parent.AddForwardArc(arc);
+            //            fragmentNode.AddReverseArc(arc);
           }
           yield return fragmentNode; // no tracing if there are no parents
@@ -79 +81 @@
         if (parents.Count == 1) {
           // we are tracing a mutation operation
-          var fragmentNode = new FragmentNode {
-            Content = node,
+          var fragmentNode = new FragmentNode(node) {
             SubtreeIndex = index,
             FragmentIndex = fragment.Index1
@@ -86 +87 @@
           if (parent != null) {
             var arc = new Arc(parent, fragmentNode);
-            parent.AddForwardArc(arc);
-            fragmentNode.AddReverseArc(arc);
+            parent.AddArc(arc);
+            fragmentNode.AddArc(arc);
           }
           node = parents[0];
@@ -138 +139 @@
             if (fragment.Index1 < index + subtreeLength) {
               // subtree contains fragment => bifurcation point in the fragment graph
-              var fragmentNode = new FragmentNode {
-                Content = node,
+              var fragmentNode = new FragmentNode(node) {
                 SubtreeIndex = index,
                 FragmentIndex = fragment.Index1
@@ -145 +145 @@
               if (parent != null) {
                 var arc = new Arc(parent, fragmentNode);
-                parent.AddForwardArc(arc);
-                fragmentNode.AddReverseArc(arc);
+                parent.AddArc(arc);
+                fragmentNode.AddArc(arc);
               }
               yield return fragmentNode;