protected static void ContainsEdge_SourceTarget_UndirectedGraph_Test(
[NotNull] IMutableUndirectedGraph <int, Edge <int> > graph)
{
var edge1 = new Edge <int>(1, 2);
var edge2 = new Edge <int>(1, 3);
var edge3 = new Edge <int>(2, 2);
Assert.IsFalse(graph.ContainsEdge(1, 2));
Assert.IsFalse(graph.ContainsEdge(2, 1));
graph.AddVerticesAndEdge(edge1);
Assert.IsTrue(graph.ContainsEdge(1, 2));
Assert.IsTrue(graph.ContainsEdge(2, 1));
graph.AddVerticesAndEdge(edge2);
Assert.IsTrue(graph.ContainsEdge(1, 3));
Assert.IsTrue(graph.ContainsEdge(3, 1));
graph.AddVerticesAndEdge(edge3);
Assert.IsTrue(graph.ContainsEdge(2, 2));
// Vertices is not present in the graph
Assert.IsFalse(graph.ContainsEdge(0, 4));
Assert.IsFalse(graph.ContainsEdge(1, 4));
Assert.IsFalse(graph.ContainsEdge(4, 1));
}
void IMutableUndirectedGraph <TVertex, TEdge> .ClearAdjacentEdges(TVertex vertex)
{
IMutableUndirectedGraph <TVertex, TEdge> ithis = this;
Contract.Requires(vertex != null);
Contract.Ensures(ithis.AdjacentDegree(vertex) == 0);
}
/// <summary>
/// Fills the given <paramref name="graph"/> with <paramref name="vertexCount"/> vertices
/// and <paramref name="edgeCount"/> edges created randomly between vertices (undirected graph).
/// </summary>
/// <typeparam name="TVertex">Vertex type.</typeparam>
/// <typeparam name="TEdge">Edge type.</typeparam>
/// <param name="graph">Graph to fill.</param>
/// <param name="vertexFactory">Vertex factory method.</param>
/// <param name="edgeFactory">Edge factory method.</param>
/// <param name="rng">Random number generator.</param>
/// <param name="vertexCount">Number of vertices to create.</param>
/// <param name="edgeCount">Number of edges to create.</param>
/// <param name="selfEdges">Indicates if self edge are allowed.</param>
public static void Create <TVertex, TEdge>(
[NotNull] IMutableUndirectedGraph <TVertex, TEdge> graph,
[NotNull, InstantHandle] VertexFactory <TVertex> vertexFactory,
[NotNull, InstantHandle] EdgeFactory <TVertex, TEdge> edgeFactory,
[NotNull] Random rng,
int vertexCount,
int edgeCount,
bool selfEdges)
where TEdge : IEdge <TVertex>
{
CreateInternal(graph, vertexFactory, edgeFactory, rng, vertexCount, edgeCount, selfEdges);
}
/// <summary>
/// Fills the given <paramref name="graph"/> with <paramref name="vertexCount"/> vertices
/// and <paramref name="edgeCount"/> edges created randomly between vertices (undirected graph).
/// </summary>
/// <typeparam name="TVertex">Vertex type.</typeparam>
/// <typeparam name="TEdge">Edge type.</typeparam>
/// <param name="graph">Graph to fill.</param>
/// <param name="vertexFactory">Vertex factory method.</param>
/// <param name="edgeFactory">Edge factory method.</param>
/// <param name="rng">Random number generator.</param>
/// <param name="vertexCount">Number of vertices to create.</param>
/// <param name="edgeCount">Number of edges to create.</param>
/// <param name="selfEdges">Indicates if self edge are allowed.</param>
public static void Create <TVertex, TEdge>(
IMutableUndirectedGraph <TVertex, TEdge> graph,
VertexFactory <TVertex> vertexFactory,
EdgeFactory <TVertex, TEdge> edgeFactory,
Random rng,
int vertexCount,
int edgeCount,
bool selfEdges
)
where TEdge : IEdge <TVertex>
{
CreateInternal(graph, vertexFactory, edgeFactory, rng, vertexCount, edgeCount, selfEdges);
}
int IMutableUndirectedGraph <TVertex, TEdge> .RemoveAdjacentEdgeIf(
TVertex vertex,
EdgePredicate <TVertex, TEdge> predicate)
{
IMutableUndirectedGraph <TVertex, TEdge> ithis = this;
Contract.Requires(vertex != null);
Contract.Requires(predicate != null);
Contract.Ensures(Contract.Result <int>() == Contract.OldValue(Enumerable.Count(ithis.AdjacentEdges(vertex), e => predicate(e))));
Contract.Ensures(Enumerable.All(ithis.AdjacentEdges(vertex), v => !predicate(v)));
return(default(int));
}
protected static void AdjacentEdge_Throws_Test(
[NotNull] IMutableUndirectedGraph <int, Edge <int> > graph)
{
const int vertex1 = 1;
const int vertex2 = 2;
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
Assert.Throws <VertexNotFoundException>(() => graph.AdjacentEdge(vertex1, 0));
graph.AddVertex(vertex1);
graph.AddVertex(vertex2);
AssertIndexOutOfRange(() => graph.AdjacentEdge(vertex1, 0));
graph.AddEdge(new Edge <int>(1, 2));
AssertIndexOutOfRange(() => graph.AdjacentEdge(vertex1, 5));
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
}
public static void Create <TVertex, TEdge>(
IMutableUndirectedGraph <TVertex, TEdge> g,
VertexFactory <TVertex> vertexFactory,
EdgeFactory <TVertex, TEdge> edgeFactory,
Random rnd,
int vertexCount,
int edgeCount,
bool selfEdges
) where TEdge : IEdge <TVertex>
{
//Contract.Requires(g != null);
//Contract.Requires(vertexFactory != null);
//Contract.Requires(edgeFactory != null);
//Contract.Requires(rnd != null);
//Contract.Requires(vertexCount > 0);
//Contract.Requires(edgeCount >= 0);
//Contract.Requires(
// !(!g.AllowParallelEdges && !selfEdges) ||
// edgeCount <= vertexCount * (vertexCount - 1) / 2
// );
var vertices = new TVertex[vertexCount];
for (int i = 0; i < vertexCount; ++i)
{
g.AddVertex(vertices[i] = vertexFactory());
}
TVertex a;
TVertex b;
int j = 0;
while (j < edgeCount)
{
a = vertices[rnd.Next(vertexCount)];
do
{
b = vertices[rnd.Next(vertexCount)];
}while (selfEdges == false && a.Equals(b));
if (g.AddEdge(edgeFactory(a, b)))
{
++j;
}
}
}
protected static void AdjacentEdge_Test(
[NotNull] IMutableUndirectedGraph <int, Edge <int> > graph)
{
var edge11 = new Edge <int>(1, 1);
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
var edge24 = new Edge <int>(2, 4);
var edge33 = new Edge <int>(3, 3);
var edge41 = new Edge <int>(4, 1);
graph.AddVerticesAndEdgeRange(new[] { edge11, edge12, edge13, edge24, edge33, edge41 });
Assert.AreSame(edge11, graph.AdjacentEdge(1, 0));
Assert.AreSame(edge13, graph.AdjacentEdge(1, 2));
Assert.AreSame(edge41, graph.AdjacentEdge(1, 3));
Assert.AreSame(edge13, graph.AdjacentEdge(3, 0));
Assert.AreSame(edge33, graph.AdjacentEdge(3, 1));
Assert.AreSame(edge24, graph.AdjacentEdge(4, 0));
}
protected static void AdjacentEdges_Test(
[NotNull] IMutableUndirectedGraph <int, Edge <int> > graph)
{
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
var edge14 = new Edge <int>(1, 4);
var edge24 = new Edge <int>(2, 4);
var edge31 = new Edge <int>(3, 1);
var edge33 = new Edge <int>(3, 3);
graph.AddVertex(1);
AssertNoAdjacentEdge(graph, 1);
graph.AddVertex(5);
graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });
AssertHasAdjacentEdges(graph, 1, new[] { edge12, edge13, edge14, edge31 });
AssertHasAdjacentEdges(graph, 2, new[] { edge12, edge24 });
AssertHasAdjacentEdges(graph, 3, new[] { edge13, edge31, edge33 }, 4); // Has self edge counting twice
AssertHasAdjacentEdges(graph, 4, new[] { edge14, edge24 });
AssertNoAdjacentEdge(graph, 5);
}
protected static void TryGetEdge_UndirectedGraph_Test(
[NotNull] IMutableUndirectedGraph <int, Edge <int> > graph)
{
var edge1 = new Edge <int>(1, 2);
var edge2 = new Edge <int>(1, 2);
var edge3 = new Edge <int>(1, 3);
var edge4 = new Edge <int>(2, 2);
var edge5 = new Edge <int>(2, 4);
var edge6 = new Edge <int>(3, 1);
var edge7 = new Edge <int>(5, 2);
graph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
Assert.IsFalse(graph.TryGetEdge(0, 10, out _));
Assert.IsFalse(graph.TryGetEdge(0, 1, out _));
Assert.IsTrue(graph.TryGetEdge(2, 4, out Edge <int> gotEdge));
Assert.AreSame(edge5, gotEdge);
Assert.IsTrue(graph.TryGetEdge(1, 2, out gotEdge));
Assert.AreSame(edge1, gotEdge);
Assert.IsTrue(graph.TryGetEdge(2, 2, out gotEdge));
Assert.AreSame(edge4, gotEdge);
// 1 -> 2 is present in this undirected graph
Assert.IsTrue(graph.TryGetEdge(2, 1, out gotEdge));
Assert.AreSame(edge1, gotEdge);
Assert.IsTrue(graph.TryGetEdge(5, 2, out gotEdge));
Assert.AreSame(edge7, gotEdge);
// 5 -> 2 is present in this undirected graph
Assert.IsTrue(graph.TryGetEdge(2, 5, out gotEdge));
Assert.AreSame(edge7, gotEdge);
}
