public void Should_be_able_to_break_cycles_by_removing_any_removable_cycle_edge()
{
var clonedGraph = _graph.Clone();
clonedGraph.Edges.Any(Is_B_to_C2).ShouldBeTrue();
var removedEdges = clonedGraph.BreakCycles(Is_B_to_C2);
clonedGraph.Edges.Any(Is_B_to_C2).ShouldBeFalse("Removable edge B-to-C2 was not removed.");
clonedGraph.Edges.Count().ShouldBe(_graph.Edges.Count() - 1);
removedEdges.Single(Is_B_to_C2).ShouldNotBeNull();
clonedGraph = _graph.Clone();
clonedGraph.Edges.Any(Is_C2_to_E2).ShouldBeTrue();
removedEdges = clonedGraph.BreakCycles(Is_C2_to_E2);
clonedGraph.Edges.Any(Is_C2_to_E2).ShouldBeFalse("Removable edge C2-to-E2 was not removed.");
clonedGraph.Edges.Count().ShouldBe(_graph.Edges.Count() - 1);
removedEdges.Single(Is_C2_to_E2).ShouldNotBeNull();
clonedGraph = _graph.Clone();
clonedGraph.Edges.Any(Is_E2_to_B).ShouldBeTrue();
removedEdges = clonedGraph.BreakCycles(Is_E2_to_B);
clonedGraph.Edges.Any(Is_E2_to_B).ShouldBeFalse("Removable edge E2-to-B was not removed.");
clonedGraph.Edges.Count().ShouldBe(_graph.Edges.Count() - 1);
removedEdges.Single(Is_E2_to_B).ShouldNotBeNull();
}
public void Should_be_able_to_break_the_cycles()
{
var clonedGraph = _graph.Clone();
IReadOnlyList <IEdge <string> > removedEdges = null;
Should.NotThrow(() =>
{
removedEdges = clonedGraph.BreakCycles(e => true);
Console.WriteLine("Removed edges:");
foreach (IEdge <string> removedEdge in removedEdges)
{
Console.WriteLine(removedEdge);
}
});
Should.NotThrow(() => clonedGraph.ValidateGraph());
clonedGraph.Edges.Count().ShouldBe(_graph.Edges.Count() - 4);
removedEdges.Count().ShouldBe(4);
removedEdges.SingleOrDefault(a => a.Source == "E2" && a.Target == "B").ShouldNotBeNull();
removedEdges.SingleOrDefault(a => a.Source == "D2" && a.Target == "A").ShouldNotBeNull();
removedEdges.SingleOrDefault(a => a.Source == "C1" && a.Target == "C1").ShouldNotBeNull();
removedEdges.SingleOrDefault(a => a.Source == "B" && a.Target == "B").ShouldNotBeNull();
}
private static IEnumerable <ResourceLoadOrder> GetGroupedLoadOrder(
BidirectionalGraph <Resource, AssociationViewEdge> resourceGraph)
{
int groupNumber = 1;
var executionGraph = resourceGraph.Clone();
var loadableResources = GetLoadableResources();
while (loadableResources.Any())
{
foreach (Resource loadableResource in loadableResources)
{
executionGraph.RemoveVertex(loadableResource);
yield return(new ResourceLoadOrder
{
Resource = GetNodeId(loadableResource),
Order = groupNumber
});
}
groupNumber++;
loadableResources = GetLoadableResources();
}
List <Resource> GetLoadableResources()
{
return(executionGraph.Vertices.Where(v => !executionGraph.InEdges(v).Any())
.OrderBy(GetNodeId)
.ToList());
}
}
private BidirectionalGraph <DataVertex, DataEdge> RemoveEdge(BidirectionalGraph <DataVertex, DataEdge> old, DataEdge edgeRemoving)
{
// get copy of the grapth using Serialization and Deserialization
var copyGraph = old.Clone();
// remove the edge
foreach (var edge in copyGraph.Edges)
{
if (edge == edgeRemoving)
{
copyGraph.RemoveEdge(edge);
break;
}
}
// get all edges but the removing one
var oldEdges = new List <DataEdge>();
foreach (var edge in old.Edges)
{
if (edge != edgeRemoving)
{
oldEdges.Add(edge);
}
}
return(copyGraph);
}
public void Clone()
{
var graph = new BidirectionalGraph <int, Edge <int> >();
graph.AddVertexRange(new[] { 1, 2, 3 });
graph.AddEdge(new Edge <int>(1, 2));
graph.AddEdge(new Edge <int>(2, 3));
graph.AddEdge(new Edge <int>(3, 1));
Assert.AreEqual(3, graph.VertexCount);
Assert.AreEqual(3, graph.EdgeCount);
var clonedGraph = graph.Clone();
Assert.AreEqual(3, clonedGraph.VertexCount);
Assert.AreEqual(3, clonedGraph.EdgeCount);
clonedGraph.AddVertexRange(new[] { 10, 11, 12, 13 });
clonedGraph.AddEdge(new Edge <int>(10, 11));
Assert.AreEqual(7, clonedGraph.VertexCount);
Assert.AreEqual(4, clonedGraph.EdgeCount);
int edgeCount = clonedGraph.Edges.Count();
Assert.AreEqual(4, edgeCount);
Assert.AreEqual(3, graph.VertexCount);
Assert.AreEqual(3, graph.EdgeCount);
}
public void CloneTest()
{
var g = new BidirectionalGraph<int, Edge<int>>();
g.AddVertexRange(new int[3] {1, 2, 3});
g.AddEdge(new Edge<int>(1, 2));
g.AddEdge(new Edge<int>(2, 3));
g.AddEdge(new Edge<int>(3, 1));
Assert.AreEqual(3, g.VertexCount);
Assert.AreEqual(3, g.EdgeCount);
var h = g.Clone();
Assert.AreEqual(3, h.VertexCount);
Assert.AreEqual(3, h.EdgeCount);
h.AddVertexRange(new int[4] { 10, 11, 12, 13 });
h.AddEdge(new Edge<int>(10, 11));
Assert.AreEqual(7, h.VertexCount);
Assert.AreEqual(4, h.EdgeCount);
var i = 0;
foreach (var e in h.Edges)
i++;
Assert.AreEqual(4, i);
Assert.AreEqual(3, g.VertexCount);
Assert.AreEqual(3, g.EdgeCount);
}
private ImmutableBidirectionalGraph <TVertex, TEdge> CloneAndMutate(Action <BidirectionalGraph <TVertex, TEdge> > mutatorAction)
{
var graph = _graph.Clone();
mutatorAction.Invoke(graph);
return(CreateInstance(graph));
}
public bool Split(out Task <TVertex, TEdge> taskTake, out Task <TVertex, TEdge> taskDrop)
{
if (!CanSplit())
{
taskTake = null;
taskDrop = null;
return(false);
}
TEdge edgeForSplit = ChooseEdgeForSplit();
TVertex v1 = edgeForSplit.Source;
TVertex v2 = edgeForSplit.Target;
BidirectionalGraph <TVertex, TEdge> graphTake = _graph.Clone();
var weightsTake = new Dictionary <EquatableEdge <TVertex>, double>(_weight);
var reverseEdge = new EquatableEdge <TVertex>(edgeForSplit.Target, edgeForSplit.Source);
weightsTake.Remove(reverseEdge);
graphTake.RemoveEdgeIf(edge => edge.Equals(reverseEdge));
foreach (TEdge outEdge in graphTake.OutEdges(v1))
{
weightsTake.Remove(outEdge);
}
foreach (TEdge inEdge in graphTake.InEdges(v2))
{
weightsTake.Remove(inEdge);
}
graphTake.ClearOutEdges(v1);
graphTake.ClearInEdges(v2);
var pathTake = new BidirectionalGraph <TVertex, TEdge>(Path);
pathTake.AddEdge(edgeForSplit);
taskTake = new Task <TVertex, TEdge>(graphTake, weightsTake, pathTake, MinCost, $"Take{edgeForSplit}");
BidirectionalGraph <TVertex, TEdge> graphDrop = _graph.Clone();
var weightsDrop = new Dictionary <EquatableEdge <TVertex>, double>(_weight);
weightsDrop.Remove(edgeForSplit);
graphDrop.RemoveEdge(edgeForSplit);
taskDrop = new Task <TVertex, TEdge>(graphDrop, weightsDrop, new BidirectionalGraph <TVertex, TEdge>(Path), MinCost, $"Drop{edgeForSplit}");
return(true);
}
private BidirectionalGraph <TVertexId, VertexIdEdge <TVertexId, TEdgeId> > CloneAndMutateGraph(
[NotNull] Action <BidirectionalGraph <TVertexId, VertexIdEdge <TVertexId, TEdgeId> > > mutatorAction)
{
var graph = _graph.Clone();
mutatorAction.Invoke(graph);
return(graph);
}
public void Clone()
{
var graph = new BidirectionalGraph <int, Edge <int> >();
AssertEmptyGraph(graph);
var clonedGraph = graph.Clone();
Assert.IsNotNull(clonedGraph);
AssertEmptyGraph(clonedGraph);
clonedGraph = new BidirectionalGraph <int, Edge <int> >(graph);
Assert.IsNotNull(clonedGraph);
AssertEmptyGraph(clonedGraph);
clonedGraph = (BidirectionalGraph <int, Edge <int> >)((ICloneable)graph).Clone();
Assert.IsNotNull(clonedGraph);
AssertEmptyGraph(clonedGraph);
var edge1 = new Edge <int>(1, 2);
var edge2 = new Edge <int>(1, 3);
var edge3 = new Edge <int>(2, 3);
graph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3 });
AssertHasVertices(graph, new[] { 1, 2, 3 });
AssertHasEdges(graph, new[] { edge1, edge2, edge3 });
clonedGraph = graph.Clone();
Assert.IsNotNull(clonedGraph);
AssertHasVertices(clonedGraph, new[] { 1, 2, 3 });
AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 });
clonedGraph = new BidirectionalGraph <int, Edge <int> >(graph);
Assert.IsNotNull(clonedGraph);
AssertHasVertices(clonedGraph, new[] { 1, 2, 3 });
AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 });
clonedGraph = (BidirectionalGraph <int, Edge <int> >)((ICloneable)graph).Clone();
Assert.IsNotNull(clonedGraph);
AssertHasVertices(clonedGraph, new[] { 1, 2, 3 });
AssertHasEdges(clonedGraph, new[] { edge1, edge2, edge3 });
}
public void Should_be_able_to_break_the_cycle_by_removing_the_self_referencing_edge()
{
var clonedGraph = _graph.Clone();
var removedEdges = clonedGraph.BreakCycles(e => true);
clonedGraph.Edges.Count().ShouldBe(_graph.Edges.Count() - 1);
removedEdges.Count().ShouldBe(1);
removedEdges.SingleOrDefault(a => a.Source == "C" && a.Target == "C").ShouldNotBeNull();
}
public void NextStep()
{
_steps.Push(_graph.Clone());
var v = _graph.Vertices.First();
_graph.RemoveVertex(v);
ShowResults();
if (!_graph.Vertices.Any())
{
_hasFinished = true;
}
}
public void CloneTest()
{
var g = new BidirectionalGraph <int, Edge <int> >();
g.AddVertexRange(new int[3] {
1, 2, 3
});
g.AddEdge(new Edge <int>(1, 2));
g.AddEdge(new Edge <int>(2, 3));
g.AddEdge(new Edge <int>(3, 1));
Assert.AreEqual(3, g.VertexCount);
Assert.AreEqual(3, g.EdgeCount);
var h = g.Clone();
Assert.AreEqual(3, h.VertexCount);
Assert.AreEqual(3, h.EdgeCount);
h.AddVertexRange(new int[4] {
10, 11, 12, 13
});
h.AddEdge(new Edge <int>(10, 11));
Assert.AreEqual(7, h.VertexCount);
Assert.AreEqual(4, h.EdgeCount);
var i = 0;
foreach (var e in h.Edges)
{
i++;
}
Assert.AreEqual(4, i);
Assert.AreEqual(3, g.VertexCount);
Assert.AreEqual(3, g.EdgeCount);
}
public MutableGraph <R> Cast <R>(Func <V, R> selector, Func <R, bool> condition) where R : class
{
return(graph.Clone(selector, condition));
}
