public void Degree_Throws()
{
var wrappedGraph = new BidirectionalGraph <EquatableTestVertex, Edge <EquatableTestVertex> >();
var graph = new ReversedBidirectionalGraph <EquatableTestVertex, Edge <EquatableTestVertex> >(wrappedGraph);
Degree_Throws_Test(graph);
}
public void TryGetInEdges_Throws()
{
var wrappedGraph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var graph = new ReversedBidirectionalGraph <TestVertex, Edge <TestVertex> >(wrappedGraph);
TryGetInEdges_Throws_Test(graph);
}
private void ComputeMinimumTree(
TVertex goal,
out IDictionary <TVertex, TEdge> successors,
out IDictionary <TVertex, double> distances)
{
var reversedGraph =
new ReversedBidirectionalGraph <TVertex, TEdge>(this.VisitedGraph);
var successorsObserver =
new VertexPredecessorRecorderObserver <TVertex, SReversedEdge <TVertex, TEdge> >();
Func <SReversedEdge <TVertex, TEdge>, double> reversedEdgeWeight =
e => this.edgeWeights(e.OriginalEdge);
var distancesObserser =
new VertexDistanceRecorderObserver <TVertex, SReversedEdge <TVertex, TEdge> >(reversedEdgeWeight);
var shortestpath =
new DijkstraShortestPathAlgorithm <TVertex, SReversedEdge <TVertex, TEdge> >(
this, reversedGraph, reversedEdgeWeight, this.DistanceRelaxer);
using (successorsObserver.Attach(shortestpath))
using (distancesObserser.Attach(shortestpath))
shortestpath.Compute(goal);
successors = new Dictionary <TVertex, TEdge>();
foreach (var kv in successorsObserver.VertexPredecessors)
{
successors.Add(kv.Key, kv.Value.OriginalEdge);
}
distances = distancesObserser.Distances;
}
public void Construction()
{
var wrappedGraph = new BidirectionalGraph <int, Edge <int> >();
var graph = new ReversedBidirectionalGraph <int, Edge <int> >(wrappedGraph);
AssertGraphProperties(graph);
wrappedGraph = new BidirectionalGraph <int, Edge <int> >(true);
graph = new ReversedBidirectionalGraph <int, Edge <int> >(wrappedGraph);
AssertGraphProperties(graph);
wrappedGraph = new BidirectionalGraph <int, Edge <int> >(false);
graph = new ReversedBidirectionalGraph <int, Edge <int> >(wrappedGraph);
AssertGraphProperties(graph, false);
#region Local function
void AssertGraphProperties <TVertex, TEdge>(
ReversedBidirectionalGraph <TVertex, TEdge> g,
bool parallelEdges = true)
where TEdge : IEdge <TVertex>
{
Assert.IsTrue(g.IsDirected);
Assert.AreEqual(parallelEdges, g.AllowParallelEdges);
Assert.IsNotNull(g.OriginalGraph);
AssertEmptyGraph(g);
}
#endregion
}
public void BinarySerialization_BidirectionalGraph([NotNull] BidirectionalGraph <int, EquatableEdge <int> > graph)
{
BidirectionalGraph <int, EquatableEdge <int> > deserializedGraph =
SerializeDeserialize <int, EquatableEdge <int>, BidirectionalGraph <int, EquatableEdge <int> > >(graph);
Assert.IsTrue(EquateGraphs.Equate(graph, deserializedGraph));
var arrayGraph = new ArrayBidirectionalGraph <int, EquatableEdge <int> >(graph);
ArrayBidirectionalGraph <int, EquatableEdge <int> > deserializedGraph2 =
SerializeDeserialize <int, EquatableEdge <int>, ArrayBidirectionalGraph <int, EquatableEdge <int> > >(arrayGraph);
Assert.IsTrue(EquateGraphs.Equate(arrayGraph, deserializedGraph2));
var reversedGraph = new ReversedBidirectionalGraph <int, EquatableEdge <int> >(graph);
ReversedBidirectionalGraph <int, EquatableEdge <int> > deserializedGraph3 =
SerializeDeserialize <int, SReversedEdge <int, EquatableEdge <int> >, ReversedBidirectionalGraph <int, EquatableEdge <int> > >(reversedGraph);
Assert.IsTrue(EquateGraphs.Equate(reversedGraph, deserializedGraph3));
var undirectedBidirectionalGraph = new UndirectedBidirectionalGraph <int, EquatableEdge <int> >(graph);
UndirectedBidirectionalGraph <int, EquatableEdge <int> > deserializedGraph4 =
SerializeDeserialize <int, EquatableEdge <int>, UndirectedBidirectionalGraph <int, EquatableEdge <int> > >(undirectedBidirectionalGraph);
Assert.IsTrue(EquateGraphs.Equate(undirectedBidirectionalGraph, deserializedGraph4));
}
public void ContainsVertex_Throws()
{
var wrappedGraph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var graph = new ReversedBidirectionalGraph <TestVertex, Edge <TestVertex> >(wrappedGraph);
ContainsVertex_Throws_Test(graph);
}
public void BinarySerialization_BidirectionalGraph_Complex([NotNull] BidirectionalGraph <EquatableTestVertex, EquatableTestEdge> graph)
{
BidirectionalGraph <EquatableTestVertex, EquatableTestEdge> deserializedGraph =
SerializeDeserialize <EquatableTestVertex, EquatableTestEdge, BidirectionalGraph <EquatableTestVertex, EquatableTestEdge> >(graph);
Assert.IsTrue(EquateGraphs.Equate(graph, deserializedGraph));
var arrayGraph = new ArrayBidirectionalGraph <EquatableTestVertex, EquatableTestEdge>(graph);
ArrayBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> deserializedGraph2 =
SerializeDeserialize <EquatableTestVertex, EquatableTestEdge, ArrayBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> >(arrayGraph);
Assert.IsTrue(EquateGraphs.Equate(arrayGraph, deserializedGraph2));
var reversedGraph = new ReversedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge>(graph);
ReversedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> deserializedGraph3 =
SerializeDeserialize <EquatableTestVertex, SReversedEdge <EquatableTestVertex, EquatableTestEdge>, ReversedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> >(reversedGraph);
Assert.IsTrue(EquateGraphs.Equate(reversedGraph, deserializedGraph3));
var undirectedBidirectionalGraph = new UndirectedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge>(graph);
UndirectedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> deserializedGraph4 =
SerializeDeserialize <EquatableTestVertex, EquatableTestEdge, UndirectedBidirectionalGraph <EquatableTestVertex, EquatableTestEdge> >(undirectedBidirectionalGraph);
Assert.IsTrue(EquateGraphs.Equate(undirectedBidirectionalGraph, deserializedGraph4));
}
public void GraphMLSerialization_BidirectionalGraph([NotNull] BidirectionalGraph <int, EquatableEdge <int> > graph)
{
AdjacencyGraph <int, EquatableEdge <int> > deserializedGraph =
SerializeDeserialize <BidirectionalGraph <int, EquatableEdge <int> >, AdjacencyGraph <int, EquatableEdge <int> > >(graph);
Assert.IsTrue(EquateGraphs.Equate(graph, deserializedGraph));
var arrayGraph = new ArrayBidirectionalGraph <int, EquatableEdge <int> >(graph);
AdjacencyGraph <int, EquatableEdge <int> > deserializedGraph2 =
SerializeDeserialize <ArrayBidirectionalGraph <int, EquatableEdge <int> >, AdjacencyGraph <int, EquatableEdge <int> > >(arrayGraph);
Assert.IsTrue(EquateGraphs.Equate(arrayGraph, deserializedGraph2));
var reversedGraph = new ReversedBidirectionalGraph <int, EquatableEdge <int> >(graph);
BidirectionalGraph <int, EquatableEdge <int> > deserializedGraph3 =
SerializeDeserialize_Reversed <ReversedBidirectionalGraph <int, EquatableEdge <int> >, BidirectionalGraph <int, EquatableEdge <int> > >(reversedGraph);
Assert.IsTrue(
EquateGraphs.Equate(
graph,
deserializedGraph3,
EqualityComparer <int> .Default,
LambdaEqualityComparer <EquatableEdge <int> > .Create(
(edge1, edge2) => Equals(edge1.Source, edge2.Target) && Equals(edge1.Target, edge2.Source),
edge => edge.GetHashCode())));
var undirectedBidirectionalGraph = new UndirectedBidirectionalGraph <int, EquatableEdge <int> >(graph);
UndirectedGraph <int, EquatableEdge <int> > deserializedGraph4 =
SerializeDeserialize <UndirectedBidirectionalGraph <int, EquatableEdge <int> >, UndirectedGraph <int, EquatableEdge <int> > >(undirectedBidirectionalGraph);
Assert.IsTrue(EquateGraphs.Equate(undirectedBidirectionalGraph, deserializedGraph4));
}
public void Test(IVertexAndEdgeListGraph g, IVertex root)
{
this.root = root;
RandomWalkAlgorithm walker = new RandomWalkAlgorithm(g);
walker.TreeEdge +=new EdgeEventHandler(walker_TreeEdge);
walker.Generate(root,50);
BidirectionalAdaptorGraph bg = new BidirectionalAdaptorGraph(g);
ReversedBidirectionalGraph rg = new ReversedBidirectionalGraph(bg);
CyclePoppingRandomTreeAlgorithm pop = new CyclePoppingRandomTreeAlgorithm(rg);
pop.InitializeVertex +=new VertexEventHandler(this.InitializeVertex);
pop.FinishVertex +=new VertexEventHandler(this.FinishVertex);
pop.TreeEdge += new EdgeEventHandler(this.TreeEdge);
pop.InitializeVertex +=new VertexEventHandler(vis.InitializeVertex);
pop.TreeEdge += new EdgeEventHandler(vis.TreeEdge);
pop.ClearTreeVertex += new VertexEventHandler(vis.ClearTreeVertex);
pop.RandomTreeWithRoot(root);
// plot tree...
GraphvizAlgorithm gv = new GraphvizAlgorithm(g,".",GraphvizImageType.Svg);
gv.FormatEdge +=new FormatEdgeEventHandler(this.FormatEdge);
gv.FormatVertex +=new FormatVertexEventHandler(this.FormatVertex);
gv.Write("randomtree");
}
public void ContainsEdge_Throws()
{
var wrappedGraph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var graph = new ReversedBidirectionalGraph <TestVertex, Edge <TestVertex> >(wrappedGraph);
ContainsEdge_NullThrows_ReversedTest(graph);
ContainsEdge_SourceTarget_Throws_Test(graph);
}
public void InEdges_Throws()
{
var wrappedGraph1 = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var graph1 = new ReversedBidirectionalGraph <TestVertex, Edge <TestVertex> >(wrappedGraph1);
InEdges_NullThrows_Test(graph1);
var wrappedGraph2 = new BidirectionalGraph <EquatableTestVertex, Edge <EquatableTestVertex> >();
var graph2 = new ReversedBidirectionalGraph <EquatableTestVertex, Edge <EquatableTestVertex> >(wrappedGraph2);
InEdges_Throws_Test(graph2);
}
public Heapshot(NativeHeapshot nativeHeapshot)
{
//Objects = nativeHeapshot.Objects;
Roots = nativeHeapshot.Roots;
TrackedTypes = nativeHeapshot.TrackedTypes;
Types = nativeHeapshot.Types;
var graphWithInReferences = new BidirectionAdapterGraph <HeapObject, Edge <HeapObject> > (nativeHeapshot.Graph);
// Construct the in-edge graph, so we can trace an object's retention path.
Graph = new ReversedBidirectionalGraph <HeapObject, Edge <HeapObject> > (graphWithInReferences);
}
public void AddEdge()
{
var wrappedGraph = new BidirectionalGraph <int, Edge <int> >();
var graph = new ReversedBidirectionalGraph <int, Edge <int> >(wrappedGraph);
var edge = new Edge <int>(1, 2);
wrappedGraph.AddVertex(1);
wrappedGraph.AddVertex(2);
wrappedGraph.AddEdge(edge);
AssertHasEdges(graph, new[] { edge }); // Graph is updated
}
public void InEdge_Throws()
{
var wrappedGraph1 = new BidirectionalGraph <int, Edge <int> >();
InEdge_Throws_ImmutableGraph_ReversedTest(
wrappedGraph1,
() => new ReversedBidirectionalGraph <int, Edge <int> >(wrappedGraph1));
var wrappedGraph2 = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var graph2 = new ReversedBidirectionalGraph <TestVertex, Edge <TestVertex> >(wrappedGraph2);
InEdge_NullThrows_Test(graph2);
}
internal Heap(
Dictionary <long, HeapRoot> roots,
Dictionary <string, long> trackedTypes,
Dictionary <long, HeapTypeInformation> types,
IVertexAndEdgeListGraph <HeapObject, Edge <HeapObject> > referenceGraph)
{
//Objects = nativeHeapshot.Objects;
Roots = roots;
TrackedTypes = trackedTypes;
Types = types;
var graphWithInReferences = new BidirectionAdapterGraph <HeapObject, Edge <HeapObject> >(referenceGraph);
// Construct the in-edge graph, so we can trace an object's retention path.
Graph = new ReversedBidirectionalGraph <HeapObject, Edge <HeapObject> >(graphWithInReferences);
}
private void ComputeMinimumTree(
[NotNull] TVertex target,
out IDictionary <TVertex, TEdge> successors,
out IDictionary <TVertex, double> distances)
{
Debug.Assert(target != null);
var reversedGraph =
new ReversedBidirectionalGraph <TVertex, TEdge>(VisitedGraph);
var successorsObserver =
new VertexPredecessorRecorderObserver <TVertex, SReversedEdge <TVertex, TEdge> >();
var distancesObserver =
new VertexDistanceRecorderObserver <TVertex, SReversedEdge <TVertex, TEdge> >(ReversedEdgeWeight);
var shortestPath =
new DijkstraShortestPathAlgorithm <TVertex, SReversedEdge <TVertex, TEdge> >(
this,
reversedGraph,
ReversedEdgeWeight,
DistanceRelaxer);
using (successorsObserver.Attach(shortestPath))
using (distancesObserver.Attach(shortestPath))
shortestPath.Compute(target);
successors = new Dictionary <TVertex, TEdge>();
foreach (KeyValuePair <TVertex, SReversedEdge <TVertex, TEdge> > pair in successorsObserver.VerticesPredecessors)
{
successors.Add(pair.Key, pair.Value.OriginalEdge);
}
distances = distancesObserver.Distances;
#region Local function
double ReversedEdgeWeight(SReversedEdge <TVertex, TEdge> edge)
{
return(_edgeWeights(edge.OriginalEdge));
}
#endregion
}
private GcTypeHeap TouchingInPlace(string typeNames)
{
if (String.IsNullOrEmpty(typeNames))
{
throw new ArgumentNullException("typeNames");
}
var filter = FilterHelper.ToFilter(typeNames);
Console.WriteLine("filtering nodes not connected to type matching '{0}'", filter);
var colors = new Dictionary <GcType, GraphColor>(this.graph.VertexCount);
foreach (var type in this.graph.Vertices)
{
colors.Add(type, GraphColor.White);
}
var rgraph = new ReversedBidirectionalGraph <GcType, GcTypeEdge>(graph);
foreach (var type in this.graph.Vertices)
{
if (filter.Match(type.Name))
{
{ // parents
var dfs =
new DepthFirstSearchAlgorithm <GcType, ReversedEdge <GcType, GcTypeEdge> >(rgraph, colors);
dfs.Visit(type);
}
{ // children
var dfs = new DepthFirstSearchAlgorithm <GcType, GcTypeEdge>(graph, colors);
dfs.Visit(type);
}
}
}
// remove all white vertices
this.graph.RemoveVertexIf(t => colors[t] == GraphColor.White);
Console.WriteLine("resulting {0} types, {1} edges", graph.VertexCount, graph.EdgeCount);
return(this);
}
private GcTypeHeap TouchingInPlace(string typeNames)
{
if (String.IsNullOrEmpty(typeNames))
throw new ArgumentNullException("typeNames");
var filter = FilterHelper.ToFilter(typeNames);
Console.WriteLine("filtering nodes not connected to type matching '{0}'", filter);
var colors = new Dictionary<GcType, GraphColor>(this.graph.VertexCount);
foreach (var type in this.graph.Vertices)
colors.Add(type, GraphColor.White);
var rgraph = new ReversedBidirectionalGraph<GcType, GcTypeEdge>(graph);
foreach (var type in this.graph.Vertices)
{
if (filter.Match(type.Name))
{
{ // parents
var dfs =
new DepthFirstSearchAlgorithm<GcType, ReversedEdge<GcType, GcTypeEdge>>(rgraph, colors);
dfs.Visit(type, -1);
}
{ // children
var dfs = new DepthFirstSearchAlgorithm<GcType, GcTypeEdge>(graph, colors);
dfs.Visit(type, -1);
}
}
}
// remove all white vertices
this.graph.RemoveVertexIf(t => colors[t] == GraphColor.White);
Console.WriteLine("resulting {0} types, {1} edges", graph.VertexCount, graph.EdgeCount);
return this;
}
