public void Construction()
{
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
Enumerable.Empty <int>(),
GetEmptyGetter <int, Edge <int> >());
AssertGraphProperties(graph);
graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
Enumerable.Empty <int>(),
GetEmptyGetter <int, Edge <int> >(),
false);
AssertGraphProperties(graph, false);
#region Local function
void AssertGraphProperties <TVertex, TEdge>(
DelegateVertexAndEdgeListGraph <TVertex, TEdge> g,
bool parallelEdges = true)
where TEdge : IEdge <TVertex>
{
Assert.IsTrue(g.IsDirected);
Assert.AreEqual(parallelEdges, g.AllowParallelEdges);
}
#endregion
}
public void ContainsVertex()
{
var data = new GraphData <int, Edge <int> >();
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
Enumerable.Empty <int>(),
data.TryGetEdges);
data.CheckCalls(0);
data.ShouldReturnValue = false;
Assert.IsFalse(graph.ContainsVertex(1));
data.CheckCalls(0); // Implementation override
data.ShouldReturnValue = true;
Assert.IsFalse(graph.ContainsVertex(1));
data.CheckCalls(0); // Implementation override
graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new[] { 1, 2 },
data.TryGetEdges);
data.ShouldReturnValue = false;
Assert.IsFalse(graph.ContainsVertex(10));
data.CheckCalls(0); // Implementation override
Assert.IsTrue(graph.ContainsVertex(2));
data.CheckCalls(0); // Implementation override
data.ShouldReturnValue = true;
Assert.IsFalse(graph.ContainsVertex(10));
data.CheckCalls(0); // Implementation override
Assert.IsTrue(graph.ContainsVertex(2));
data.CheckCalls(0); // Implementation override
}
public void OutEdges_Throws()
{
var data1 = new GraphData <int, Edge <int> >();
var graph1 = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new [] { 1 },
data1.TryGetEdges);
OutEdges_Throws_Test(data1, graph1);
// Additional tests
data1.ShouldReturnValue = true;
var edge32 = new Edge <int>(3, 2);
data1.ShouldReturnEdges = new[] { edge32 };
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Assert.Throws <VertexNotFoundException>(() => graph1.OutEdges(3));
data1.CheckCalls(0); // Vertex is not in graph so no need to call user code
var graph2 = new DelegateVertexAndEdgeListGraph <EquatableTestVertex, Edge <EquatableTestVertex> >(
Enumerable.Empty <EquatableTestVertex>(),
GetEmptyGetter <EquatableTestVertex, Edge <EquatableTestVertex> >());
OutEdges_NullThrows_Test(graph2);
}
public static void TestGunrockCcSimpleExampleQuickGraphRepresentation()
{
int[][] graph = new int[9][];
graph[0] = new [] { 1, 2, 3 };
graph[1] = new [] { 0, 2, 4 };
graph[2] = new [] { 3, 4, 5 };
graph[3] = new [] { 5, 6 };
graph[4] = new [] { 2, 5, 6 };
graph[5] = new [] { 6 };
graph[6] = new int[] { };
graph[7] = new int[] { };
graph[8] = new int[] { };
DelegateVertexAndEdgeListGraph <int, SEquatableEdge <int> > g = Enumerable.Range(0, graph.Length).ToDelegateVertexAndEdgeListGraph(v => Array.ConvertAll(graph[v], w => new SEquatableEdge <int>(v, w))
);
var arrayAdjacencyGraph = g.ToArrayAdjacencyGraph();
var res = ConnectedComponents.FindComponents <SEquatableEdge <int>, IEdgeListGraph <int, SEquatableEdge <int> > >(
arrayAdjacencyGraph);
foreach (var keyValuePair in res)
{
Console.WriteLine(keyValuePair.Key + " is in CC #" + keyValuePair.Value);
}
}
public void TryGetEdge()
{
var data = new GraphData <int, Edge <int> >();
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new[] { 1, 2, 3 },
data.TryGetEdges);
TryGetEdge_Test(data, graph);
// Additional tests
var edge13 = new Edge <int>(1, 3);
var edge14 = new Edge <int>(1, 4);
var edge21 = new Edge <int>(2, 1);
data.ShouldReturnValue = true;
data.ShouldReturnEdges = new[] { edge13, edge14, edge21 };
Assert.IsFalse(graph.TryGetEdge(1, 2, out Edge <int> gotEdge));
var edge12 = new Edge <int>(1, 2);
data.ShouldReturnEdges = new[] { edge12, edge13, edge14, edge21 };
Assert.IsTrue(graph.TryGetEdge(1, 2, out gotEdge));
Assert.AreSame(edge12, gotEdge);
var edge51 = new Edge <int>(5, 1);
var edge56 = new Edge <int>(5, 6);
data.ShouldReturnEdges = new[] { edge12, edge13, edge51, edge56 };
Assert.IsFalse(graph.TryGetEdge(1, 5, out _));
Assert.IsFalse(graph.TryGetEdge(5, 1, out _));
Assert.IsFalse(graph.TryGetEdge(5, 6, out _));
}
public void TryGetOutEdges_Throws()
{
var graph = new DelegateVertexAndEdgeListGraph <TestVertex, Edge <TestVertex> >(
Enumerable.Empty <TestVertex>(),
GetEmptyGetter <TestVertex, Edge <TestVertex> >());
TryGetOutEdges_Throws_Test(graph);
}
public void TryGetOutEdges()
{
var data = new GraphData <int, Edge <int> >();
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new[] { 1, 2, 3, 4 },
data.TryGetEdges);
TryGetOutEdges_Test(data, graph);
}
public void TryGetEdges_Throws()
{
var data = new GraphData <TestVertex, Edge <TestVertex> >();
var graph = new DelegateVertexAndEdgeListGraph <TestVertex, Edge <TestVertex> >(
Enumerable.Empty <TestVertex>(),
data.TryGetEdges);
TryGetEdges_Throws_Test(graph);
}
public void ContainsEdge()
{
var data = new GraphData <int, Edge <int> >();
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new[] { 1, 2, 3 },
data.TryGetEdges);
ContainsEdge_Test(data, graph);
}
protected static void TryGetEdges_Test(
[NotNull] GraphData <int, Edge <int> > data,
[NotNull] DelegateVertexAndEdgeListGraph <int, Edge <int> > graph)
{
data.CheckCalls(0);
data.ShouldReturnValue = false;
Assert.IsFalse(graph.TryGetEdges(0, 1, out _));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
data.ShouldReturnValue = true;
Assert.IsTrue(graph.TryGetEdges(1, 2, out IEnumerable <Edge <int> > edges));
CollectionAssert.IsEmpty(edges);
data.CheckCalls(1);
data.ShouldReturnEdges = new[] { new Edge <int>(1, 2), new Edge <int>(1, 2) };
Assert.IsTrue(graph.TryGetEdges(1, 2, out edges));
CollectionAssert.AreEqual(data.ShouldReturnEdges, edges);
data.CheckCalls(1);
var edge14 = new Edge <int>(1, 4);
var edge12 = new Edge <int>(1, 2);
var edge12Bis = new Edge <int>(1, 2);
data.ShouldReturnValue = true;
data.ShouldReturnEdges = new[] { edge14, edge12 };
Assert.IsTrue(graph.TryGetEdges(1, 2, out edges));
CollectionAssert.AreEqual(new[] { edge12 }, edges);
data.CheckCalls(1);
data.ShouldReturnEdges = new[] { edge14, edge12, edge12Bis };
Assert.IsTrue(graph.TryGetEdges(1, 2, out edges));
CollectionAssert.AreEqual(new[] { edge12, edge12Bis }, edges);
data.CheckCalls(1);
data.ShouldReturnEdges = new[] { edge14, edge12 };
Assert.IsTrue(graph.TryGetEdges(2, 1, out edges));
CollectionAssert.IsEmpty(edges);
data.CheckCalls(1);
var edge41 = new Edge <int>(4, 1);
data.ShouldReturnEdges = new[] { edge14, edge41 };
Assert.IsTrue(graph.TryGetEdges(1, 4, out edges));
CollectionAssert.IsEmpty(edges);
data.CheckCalls(1);
Assert.IsFalse(graph.TryGetEdges(4, 1, out _));
data.CheckCalls(0);
var edge45 = new Edge <int>(4, 5);
data.ShouldReturnEdges = new[] { edge14, edge41, edge45 };
Assert.IsFalse(graph.TryGetEdges(4, 5, out _));
data.CheckCalls(0);
}
public void ContainsEdge_SourceTarget()
{
var data = new GraphData <int, Edge <int> >();
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
Enumerable.Empty <int>(),
data.TryGetEdges);
data.CheckCalls(0);
data.ShouldReturnValue = false;
Assert.IsFalse(graph.ContainsEdge(1, 2));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
Assert.IsFalse(graph.ContainsEdge(2, 1));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
data.ShouldReturnValue = true;
Assert.IsFalse(graph.ContainsEdge(1, 2));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
Assert.IsFalse(graph.ContainsEdge(2, 1));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
data.ShouldReturnEdges = new[] { new Edge <int>(1, 3), new Edge <int>(1, 2) };
Assert.IsFalse(graph.ContainsEdge(1, 2)); // Vertices 1 and 2 are not part or the graph
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
Assert.IsFalse(graph.ContainsEdge(2, 1));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new[] { 1, 3 },
data.TryGetEdges);
data.ShouldReturnValue = false;
Assert.IsFalse(graph.ContainsEdge(1, 2));
data.CheckCalls(1);
Assert.IsFalse(graph.ContainsEdge(2, 1));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
data.ShouldReturnValue = true;
Assert.IsFalse(graph.ContainsEdge(1, 2));
data.CheckCalls(1);
Assert.IsFalse(graph.ContainsEdge(2, 1));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
data.ShouldReturnEdges = new[] { new Edge <int>(1, 2), new Edge <int>(1, 3) };
Assert.IsFalse(graph.ContainsEdge(1, 2)); // Vertices 2 is not part or the graph
data.CheckCalls(1);
Assert.IsFalse(graph.ContainsEdge(2, 1));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
Assert.IsTrue(graph.ContainsEdge(1, 3));
data.CheckCalls(1);
Assert.IsFalse(graph.ContainsEdge(3, 1));
data.CheckCalls(1);
}
public void Vertices()
{
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
Enumerable.Empty <int>(),
GetEmptyGetter <int, Edge <int> >());
AssertNoVertex(graph);
AssertNoVertex(graph);
graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new[] { 1, 2, 3 },
GetEmptyGetter <int, Edge <int> >());
AssertHasVertices(graph, new[] { 1, 2, 3 });
AssertHasVertices(graph, new[] { 1, 2, 3 });
}
public void OutEdge()
{
var data = new GraphData <int, Edge <int> >();
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new[] { 1, 2, 3 },
data.TryGetEdges);
OutEdge_Test(data, graph);
// Additional tests
var edge14 = new Edge <int>(1, 4);
var edge12 = new Edge <int>(1, 2);
data.ShouldReturnValue = true;
data.ShouldReturnEdges = new[] { edge14, edge12 };
Assert.AreSame(edge12, graph.OutEdge(1, 0));
data.CheckCalls(1);
}
protected static void TryGetOutEdges_Test(
[NotNull] GraphData <int, Edge <int> > data,
[NotNull] DelegateVertexAndEdgeListGraph <int, Edge <int> > graph)
{
data.CheckCalls(0);
data.ShouldReturnValue = false;
Assert.IsFalse(graph.TryGetOutEdges(5, out _));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
data.ShouldReturnValue = true;
Assert.IsTrue(graph.TryGetOutEdges(1, out IEnumerable <Edge <int> > edges));
CollectionAssert.IsEmpty(edges);
data.CheckCalls(1);
data.ShouldReturnEdges = new[] { new Edge <int>(1, 4), new Edge <int>(1, 2) };
Assert.IsTrue(graph.TryGetOutEdges(1, out edges));
CollectionAssert.AreEqual(data.ShouldReturnEdges, edges);
data.CheckCalls(1);
data.ShouldReturnEdges = null;
Assert.IsTrue(graph.TryGetOutEdges(1, out IEnumerable <Edge <int> > outEdges));
CollectionAssert.IsEmpty(outEdges);
data.CheckCalls(1);
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
var edge15 = new Edge <int>(1, 5);
var edge21 = new Edge <int>(2, 1);
var edge23 = new Edge <int>(2, 3);
data.ShouldReturnEdges = new[] { edge12, edge13, edge15, edge21, edge23 };
Assert.IsTrue(graph.TryGetOutEdges(1, out outEdges));
CollectionAssert.AreEqual(
new[] { edge12, edge13 },
outEdges);
data.CheckCalls(1);
var edge52 = new Edge <int>(5, 2);
data.ShouldReturnEdges = new[] { edge15, edge52 };
Assert.IsFalse(graph.TryGetOutEdges(5, out _));
data.CheckCalls(0); // Vertex is not in graph so no need to call user code
}
public void Edges()
{
var data = new GraphData <int, Edge <int> >();
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
Enumerable.Empty <int>(),
data.TryGetEdges);
data.ShouldReturnValue = false;
data.ShouldReturnEdges = null;
AssertNoEdge(graph);
data.ShouldReturnValue = true;
AssertNoEdge(graph);
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
data.ShouldReturnEdges = new[] { edge12, edge13 };
AssertNoEdge(graph); // No vertex so no possible edge!
graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new[] { 1, 2, 3 },
data.TryGetEdges);
data.ShouldReturnValue = true;
data.ShouldReturnEdges = null;
AssertNoEdge(graph);
var edge22 = new Edge <int>(2, 2);
var edge31 = new Edge <int>(3, 1);
data.ShouldReturnEdges = new[] { edge12, edge13, edge22, edge31 };
AssertHasEdges(graph, new[] { edge12, edge13, edge22, edge31 });
var edge15 = new Edge <int>(1, 5);
var edge51 = new Edge <int>(5, 1);
var edge56 = new Edge <int>(5, 6);
data.ShouldReturnEdges = new[] { edge12, edge13, edge22, edge31, edge15, edge51, edge56 };
// Some edges skipped because they have vertices not in the graph
AssertHasEdges(graph, new[] { edge12, edge13, edge22, edge31 });
}
public void OutEdges()
{
var data = new GraphData <int, Edge <int> >();
var graph = new DelegateVertexAndEdgeListGraph <int, Edge <int> >(
new[] { 1, 2, 3 },
data.TryGetEdges);
OutEdges_Test(data, graph);
// Additional tests
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
var edge14 = new Edge <int>(1, 4);
var edge21 = new Edge <int>(2, 1);
data.ShouldReturnValue = true;
data.ShouldReturnEdges = new[] { edge12, edge13, edge14, edge21 };
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
AssertHasOutEdges(graph, 1, new[] { edge12, edge13 });
data.CheckCalls(3);
}
private void CreateGraph()
{
Dictionary<int, int[]> dic = new Dictionary<int, int[]>(LOCATION);
dic.Add(0, new[] { 1, 24 });
dic.Add(1, new[] { 0, 2, 20, 25 });
dic.Add(2, new[] { 1, 3, 16, 25 });
dic.Add(3, new[] { 2, 4, 12, 25 });
dic.Add(4, new[] { 3, 5, 25 });
dic.Add(5, new[] { 4, 6 });
dic.Add(6, new[] { 5, 7 });
dic.Add(7, new[] { 6, 8 });
dic.Add(8, new[] { 7, 9 });
dic.Add(9, new[] { 8, 10, 13 });
dic.Add(10, new[] { 9, 11 });
dic.Add(11, new[] { 10, 12 });
dic.Add(12, new[] { 3, 11 });
dic.Add(13, new[] { 9, 14, 17 });
dic.Add(14, new[] { 13, 15 });
dic.Add(15, new[] { 14, 16 });
dic.Add(16, new[] { 2, 15 });
dic.Add(17, new[] { 13, 18, 21 });
dic.Add(18, new[] { 17, 19 });
dic.Add(19, new[] { 18, 20 });
dic.Add(20, new[] { 1, 19 });
dic.Add(21, new[] { 17, 22 });
dic.Add(22, new[] { 21, 23 });
dic.Add(23, new[] { 22, 24 });
dic.Add(24, new[] { 0, 23 });
dic.Add(25, new[] { 1, 2, 3, 4 });
this.graph = dic.ToVertexAndEdgeListGraph(
kv => Array.ConvertAll(
kv.Value, v => new SEquatableEdge<int>(kv.Key, v)
)
);
}
