protected static void TryGetInEdges_ImmutableGraph_Test(
IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
Func <IBidirectionalIncidenceGraph <int, Edge <int> > > createGraph)
{
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, 3);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
IBidirectionalIncidenceGraph <int, Edge <int> > graph = createGraph();
Assert.IsFalse(graph.TryGetInEdges(0, out _));
Assert.IsTrue(graph.TryGetInEdges(5, out IEnumerable <Edge <int> > gotEdges));
CollectionAssert.IsEmpty(gotEdges);
Assert.IsTrue(graph.TryGetInEdges(4, out gotEdges));
CollectionAssert.AreEqual(new[] { edge5 }, gotEdges);
Assert.IsTrue(graph.TryGetInEdges(2, out gotEdges));
CollectionAssert.AreEqual(new[] { edge1, edge2, edge4 }, gotEdges);
}
protected static void TryGetOutEdges_ImmutableGraph_ReversedTest(
IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
Func <IImplicitGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
{
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, 4);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
IImplicitGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();
Assert.IsFalse(graph.TryGetOutEdges(0, out _));
Assert.IsTrue(graph.TryGetOutEdges(5, out IEnumerable <SReversedEdge <int, Edge <int> > > gotEdges));
CollectionAssert.IsEmpty(gotEdges);
Assert.IsTrue(graph.TryGetOutEdges(3, out gotEdges));
AssertSameReversedEdges(new[] { edge3 }, gotEdges);
Assert.IsTrue(graph.TryGetOutEdges(2, out gotEdges));
AssertSameReversedEdges(new[] { edge1, edge2, edge4 }, gotEdges);
}
protected static void ContainsEdge_SourceTarget_ImmutableGraph_ReversedTest(
IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
Func <IIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
{
IIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();
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));
wrappedGraph.AddVerticesAndEdge(edge1);
graph = createGraph();
Assert.IsFalse(graph.ContainsEdge(1, 2));
Assert.IsTrue(graph.ContainsEdge(2, 1));
wrappedGraph.AddVerticesAndEdge(edge2);
graph = createGraph();
Assert.IsFalse(graph.ContainsEdge(1, 3));
Assert.IsTrue(graph.ContainsEdge(3, 1));
wrappedGraph.AddVerticesAndEdge(edge3);
graph = createGraph();
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));
}
protected static void TryGetEdge_ImmutableGraph_ReversedTest(
IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
Func <IIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
{
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);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6 });
IIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();
Assert.IsFalse(graph.TryGetEdge(0, 10, out _));
Assert.IsFalse(graph.TryGetEdge(0, 1, out _));
Assert.IsTrue(graph.TryGetEdge(4, 2, out SReversedEdge <int, Edge <int> > gotEdge));
AssertSameReversedEdge(edge5, gotEdge);
Assert.IsTrue(graph.TryGetEdge(2, 2, out gotEdge));
AssertSameReversedEdge(edge4, gotEdge);
Assert.IsTrue(graph.TryGetEdge(2, 1, out gotEdge));
AssertSameReversedEdge(edge1, gotEdge);
Assert.IsFalse(graph.TryGetEdge(1, 2, out _));
}
/// <summary>
/// Initializes a new instance of the <see cref="DataSetGraphPopulatorAlgorithm"/> class.
/// </summary>
/// <param name="visitedGraph">Graph to fill from <paramref name="dataSet"/>.</param>
/// <param name="dataSet"><see cref="System.Data.DataSet"/> to use to fill <paramref name="visitedGraph"/>.</param>
public DataSetGraphPopulatorAlgorithm(
[NotNull] IMutableVertexAndEdgeSet <DataTable, DataRelationEdge> visitedGraph,
[NotNull] DataSet dataSet)
: base(visitedGraph)
{
DataSet = dataSet ?? throw new ArgumentNullException(nameof(dataSet));
}
protected static void TryGetEdge_ImmutableGraph_Test(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
[NotNull, InstantHandle] Func <IIncidenceGraph <int, SEquatableEdge <int> > > createGraph)
{
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);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6 });
IIncidenceGraph <int, SEquatableEdge <int> > graph = createGraph();
Assert.IsFalse(graph.TryGetEdge(0, 10, out _));
Assert.IsFalse(graph.TryGetEdge(0, 1, out _));
Assert.IsTrue(graph.TryGetEdge(2, 4, out SEquatableEdge <int> gotEdge));
Assert.AreEqual(new SEquatableEdge <int>(2, 4), gotEdge);
Assert.IsTrue(graph.TryGetEdge(2, 2, out gotEdge));
Assert.AreEqual(new SEquatableEdge <int>(2, 2), gotEdge);
Assert.IsTrue(graph.TryGetEdge(1, 2, out gotEdge));
Assert.AreEqual(new SEquatableEdge <int>(1, 2), gotEdge);
Assert.IsFalse(graph.TryGetEdge(2, 1, out _));
}
protected static void TryGetInEdges_ImmutableGraph_ReversedTest(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
[NotNull, InstantHandle] Func <IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
{
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>(1, 1);
var edge5 = new Edge <int>(2, 4);
var edge6 = new Edge <int>(3, 1);
var edge7 = new Edge <int>(4, 5);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();
Assert.IsFalse(graph.TryGetInEdges(0, out _));
Assert.IsTrue(graph.TryGetInEdges(5, out IEnumerable <SReversedEdge <int, Edge <int> > > gotEdges));
CollectionAssert.IsEmpty(gotEdges);
Assert.IsTrue(graph.TryGetInEdges(4, out gotEdges));
AssertSameReversedEdges(new[] { edge7 }, gotEdges);
Assert.IsTrue(graph.TryGetInEdges(1, out gotEdges));
AssertSameReversedEdges(new[] { edge1, edge2, edge3, edge4 }, gotEdges);
}
protected static void ContainsEdge_SourceTarget_ImmutableGraph_UndirectedGraph_Test(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
[NotNull, InstantHandle] Func <IImplicitUndirectedGraph <int, Edge <int> > > createGraph)
{
var edge1 = new Edge <int>(1, 2);
var edge2 = new Edge <int>(1, 3);
var edge3 = new Edge <int>(2, 2);
IImplicitUndirectedGraph <int, Edge <int> > graph = createGraph();
Assert.IsFalse(graph.ContainsEdge(1, 2));
Assert.IsFalse(graph.ContainsEdge(2, 1));
wrappedGraph.AddVerticesAndEdge(edge1);
graph = createGraph();
Assert.IsTrue(graph.ContainsEdge(1, 2));
Assert.IsTrue(graph.ContainsEdge(2, 1));
wrappedGraph.AddVerticesAndEdge(edge2);
graph = createGraph();
Assert.IsTrue(graph.ContainsEdge(1, 3));
Assert.IsTrue(graph.ContainsEdge(3, 1));
wrappedGraph.AddVerticesAndEdge(edge3);
graph = createGraph();
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));
}
protected static void AdjacentEdges_ImmutableGraph_Test(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
[NotNull, InstantHandle] Func <IImplicitUndirectedGraph <int, Edge <int> > > createGraph)
{
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);
wrappedGraph.AddVertex(1);
IImplicitUndirectedGraph <int, Edge <int> > graph = createGraph();
AssertNoAdjacentEdge(graph, 1);
wrappedGraph.AddVertex(5);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });
graph = createGraph();
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 TryGetOutEdges_ImmutableGraph_Test(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
[NotNull, InstantHandle] Func <IImplicitGraph <int, SEquatableEdge <int> > > createGraph)
{
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>(4, 5);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
IImplicitGraph <int, SEquatableEdge <int> > graph = createGraph();
Assert.IsFalse(graph.TryGetOutEdges(0, out _));
Assert.IsTrue(graph.TryGetOutEdges(5, out IEnumerable <SEquatableEdge <int> > gotEdges));
CollectionAssert.IsEmpty(gotEdges);
Assert.IsTrue(graph.TryGetOutEdges(3, out gotEdges));
CollectionAssert.AreEqual(
new[] { new SEquatableEdge <int>(3, 1) },
gotEdges);
Assert.IsTrue(graph.TryGetOutEdges(1, out gotEdges));
CollectionAssert.AreEqual(
new[]
{
new SEquatableEdge <int>(1, 2),
new SEquatableEdge <int>(1, 2),
new SEquatableEdge <int>(1, 3)
},
gotEdges);
}
/// <summary>
/// Clones a graph to another graph
/// </summary>
/// <typeparam name="TVertex">type of the vertices</typeparam>
/// <typeparam name="TEdge">type of the edges</typeparam>
/// <param name="g"></param>
/// <param name="vertexCloner"></param>
/// <param name="edgeCloner"></param>
/// <param name="clone"></param>
public static void Clone <TVertex, TEdge>(
#if !NET20
this
#endif
IVertexAndEdgeListGraph <TVertex, TEdge> g,
Func <TVertex, TVertex> vertexCloner,
Func <TEdge, TVertex, TVertex, TEdge> edgeCloner,
IMutableVertexAndEdgeSet <TVertex, TEdge> clone)
where TEdge : IEdge <TVertex>
{
Contract.Requires(g != null);
Contract.Requires(vertexCloner != null);
Contract.Requires(edgeCloner != null);
Contract.Requires(clone != null);
var vertexClones = new Dictionary <TVertex, TVertex>(g.VertexCount);
foreach (var v in g.Vertices)
{
var vc = vertexCloner(v);
clone.AddVertex(vc);
vertexClones.Add(v, vc);
}
foreach (var edge in g.Edges)
{
var ec = edgeCloner(
edge,
vertexClones[edge.Source],
vertexClones[edge.Target]);
clone.AddEdge(ec);
}
}
public CloneableVertexGraphExplorerAlgorithm(
IAlgorithmComponent host,
IMutableVertexAndEdgeSet <TVertex, TEdge> visitedGraph
)
: base(host, visitedGraph)
{
}
protected static void ContainsEdge_Test(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > graph)
{
ContainsEdge_Test(
graph,
edge => graph.AddVerticesAndEdge(edge));
}
/// <summary>
/// Initializes a new instance of the <see cref="AllVerticesGraphAugmentorAlgorithm{TVertex,TEdge}"/> class.
/// </summary>
/// <param name="visitedGraph">Graph to visit.</param>
/// <param name="vertexFactory">Vertex factory method.</param>
/// <param name="edgeFactory">Edge factory method.</param>
public AllVerticesGraphAugmentorAlgorithm(
[NotNull] IMutableVertexAndEdgeSet <TVertex, TEdge> visitedGraph,
[NotNull] VertexFactory <TVertex> vertexFactory,
[NotNull] EdgeFactory <TVertex, TEdge> edgeFactory)
: this(null, visitedGraph, vertexFactory, edgeFactory)
{
}
protected static void AddVerticesAndEdgeRange_Throws_Test(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > graph)
{
int vertexAdded = 0;
int edgeAdded = 0;
AssertEmptyGraph(graph);
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
graph.VertexAdded += v =>
{
Assert.IsNotNull(v);
++vertexAdded;
};
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
graph.EdgeAdded += e =>
{
Assert.IsNotNull(e);
++edgeAdded;
};
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => graph.AddVerticesAndEdgeRange(null));
// Edge 1, 2, 3
var edge1 = new Edge <int>(1, 2);
var edge3 = new Edge <int>(1, 3);
Assert.Throws <ArgumentNullException>(() => graph.AddVerticesAndEdgeRange(new[] { edge1, null, edge3 }));
Assert.AreEqual(0, vertexAdded);
Assert.AreEqual(0, edgeAdded);
AssertEmptyGraph(graph);
}
protected static void InEdges_ImmutableGraph_ReversedTest(
IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
Func <IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
{
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
var edge14 = new Edge <int>(1, 4);
var edge33 = new Edge <int>(3, 3);
var edge34 = new Edge <int>(3, 4);
var edge43 = new Edge <int>(4, 3);
wrappedGraph.AddVertex(1);
IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();
AssertNoInEdge(graph, 1);
AssertNoOutEdge(graph, 1);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge33, edge34, edge43 });
graph = createGraph();
AssertNoOutEdge(graph, 1);
AssertHasReversedOutEdges(graph, 2, new[] { edge12 });
AssertHasReversedOutEdges(graph, 3, new[] { edge13, edge33, edge43 });
AssertHasReversedOutEdges(graph, 4, new[] { edge14, edge34 });
AssertHasReversedInEdges(graph, 1, new[] { edge12, edge13, edge14 });
AssertNoInEdge(graph, 2);
AssertHasReversedInEdges(graph, 3, new[] { edge33, edge34 });
AssertHasReversedInEdges(graph, 4, new[] { edge43 });
}
protected static void InEdges_ImmutableGraph_Test(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
[NotNull, InstantHandle] Func <IBidirectionalIncidenceGraph <int, Edge <int> > > createGraph)
{
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 edge32 = new Edge <int>(3, 2);
var edge33 = new Edge <int>(3, 3);
wrappedGraph.AddVertex(1);
IBidirectionalIncidenceGraph <int, Edge <int> > graph = createGraph();
AssertNoInEdge(graph, 1);
AssertNoOutEdge(graph, 1);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge32, edge33 });
graph = createGraph();
AssertHasOutEdges(graph, 1, new[] { edge12, edge13, edge14 });
AssertHasOutEdges(graph, 2, new[] { edge24 });
AssertHasOutEdges(graph, 3, new[] { edge32, edge33 });
AssertNoOutEdge(graph, 4);
AssertNoInEdge(graph, 1);
AssertHasInEdges(graph, 2, new[] { edge12, edge32 });
AssertHasInEdges(graph, 3, new[] { edge13, edge33 });
AssertHasInEdges(graph, 4, new[] { edge14, edge24 });
}
/// <summary>
/// Initializes a new instance of the <see cref="AllVerticesGraphAugmentorAlgorithm{TVertex,TEdge}"/> class.
/// </summary>
/// <param name="host">Host to use if set, otherwise use this reference.</param>
/// <param name="visitedGraph">Graph to visit.</param>
/// <param name="vertexFactory">Vertex factory method.</param>
/// <param name="edgeFactory">Edge factory method.</param>
public AllVerticesGraphAugmentorAlgorithm(
IAlgorithmComponent host,
IMutableVertexAndEdgeSet <TVertex, TEdge> visitedGraph,
VertexFactory <TVertex> vertexFactory,
EdgeFactory <TVertex, TEdge> edgeFactory)
: base(host, visitedGraph, vertexFactory, edgeFactory)
{
}
protected static void AddVerticesAndEdge_Throws_Test <TVertex, TEdge>(
[NotNull] IMutableVertexAndEdgeSet <TVertex, TEdge> graph)
where TEdge : class, IEdge <TVertex>
{
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => graph.AddVerticesAndEdge(null));
AssertEmptyGraph(graph);
}
/// <summary>
/// Initializes a new instance of the <see cref="AllVerticesGraphAugmentorAlgorithm{TVertex,TEdge}"/> class.
/// </summary>
/// <param name="host">Host to use if set, otherwise use this reference.</param>
/// <param name="visitedGraph">Graph to visit.</param>
/// <param name="vertexFactory">Vertex factory method.</param>
/// <param name="edgeFactory">Edge factory method.</param>
public AllVerticesGraphAugmentorAlgorithm(
[CanBeNull] IAlgorithmComponent host,
[NotNull] IMutableVertexAndEdgeSet <TVertex, TEdge> visitedGraph,
[NotNull] VertexFactory <TVertex> vertexFactory,
[NotNull] EdgeFactory <TVertex, TEdge> edgeFactory)
: base(host, visitedGraph, vertexFactory, edgeFactory)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BipartiteToMaximumFlowGraphAugmentorAlgorithm{TVertex,TEdge}"/> class.
/// </summary>
/// <param name="visitedGraph">Graph to visit.</param>
/// <param name="sourceToVertices">Vertices to which creating augmented edge from super source.</param>
/// <param name="verticesToSink">Vertices from which creating augmented edge to super sink.</param>
/// <param name="vertexFactory">Vertex factory method.</param>
/// <param name="edgeFactory">Edge factory method.</param>
public BipartiteToMaximumFlowGraphAugmentorAlgorithm(
[NotNull] IMutableVertexAndEdgeSet <TVertex, TEdge> visitedGraph,
[NotNull, ItemNotNull] IEnumerable <TVertex> sourceToVertices,
[NotNull, ItemNotNull] IEnumerable <TVertex> verticesToSink,
[NotNull] VertexFactory <TVertex> vertexFactory,
[NotNull] EdgeFactory <TVertex, TEdge> edgeFactory)
: this(null, visitedGraph, sourceToVertices, verticesToSink, vertexFactory, edgeFactory)
{
}
int IMutableVertexAndEdgeSet <TVertex, TEdge> .AddVerticesAndEdgeRange(IEnumerable <TEdge> edges)
{
IMutableVertexAndEdgeSet <TVertex, TEdge> ithis = this;
Contract.Requires(edges != null);
Contract.Requires(typeof(TEdge).GetTypeInfo().IsValueType || Enumerable.All(edges, edge => edge != null));
Contract.Ensures(ithis.EdgeCount == Contract.OldValue(ithis.EdgeCount) + Contract.Result <int>());
return(default(int));
}
public BipartiteToMaximumFlowGraphAugmentorAlgorithm(
IMutableVertexAndEdgeSet <TVertex, TEdge> visitedGraph,
IEnumerable <TVertex> vertexSetA,
IEnumerable <TVertex> vertexSetB,
VertexFactory <TVertex> vertexFactory,
EdgeFactory <TVertex, TEdge> edgeFactory
)
: this(null, visitedGraph, vertexSetA, vertexSetB, vertexFactory, edgeFactory)
{
}
bool IMutableVertexAndEdgeSet <TVertex, TEdge> .AddVerticesAndEdge(TEdge edge)
{
IMutableVertexAndEdgeSet <TVertex, TEdge> ithis = this;
Contract.Requires(edge != null);
Contract.Ensures(ithis.ContainsEdge(edge));
Contract.Ensures(ithis.AllowParallelEdges || Contract.Result <bool>() == Contract.OldValue(!ithis.ContainsEdge(edge)));
Contract.Ensures(ithis.EdgeCount == Contract.OldValue(ithis.EdgeCount) + (Contract.Result <bool>() ? 1 : 0));
return(default(bool));
}
protected static void RemoveVertexIf_Test(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > graph)
{
int verticesRemoved = 0;
int edgesRemoved = 0;
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
graph.VertexRemoved += v =>
{
Assert.IsNotNull(v);
// ReSharper disable once AccessToModifiedClosure
++verticesRemoved;
};
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
graph.EdgeRemoved += e =>
{
Assert.IsNotNull(e);
// ReSharper disable once AccessToModifiedClosure
++edgesRemoved;
};
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.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });
Assert.AreEqual(0, graph.RemoveVertexIf(vertex => vertex > 10));
CheckCounters(0, 0);
Assert.AreEqual(2, graph.RemoveVertexIf(vertex => vertex > 2));
CheckCounters(2, 5);
AssertHasVertices(graph, new[] { 1, 2 });
AssertHasEdges(graph, new[] { edge12 });
Assert.AreEqual(2, graph.RemoveVertexIf(_ => true));
CheckCounters(2, 1);
AssertEmptyGraph(graph);
#region Local function
void CheckCounters(int expectedRemovedVertices, int expectedRemovedEdges)
{
Assert.AreEqual(expectedRemovedVertices, verticesRemoved);
Assert.AreEqual(expectedRemovedEdges, edgesRemoved);
verticesRemoved = 0;
edgesRemoved = 0;
}
#endregion
}
bool IMutableVertexAndEdgeSet <TVertex, TEdge> .AddVerticesAndEdge(TEdge edge)
{
IMutableVertexAndEdgeSet <TVertex, TEdge> ithis = this;
Contract.Requires(edge != null);
Contract.Ensures(ithis.ContainsEdge(edge));
// MJ: This doesn't work, because the check for ContainsEdge bugs out
// Contract.Ensures(ithis.AllowParallelEdges || Contract.Result<bool>() == Contract.OldValue(!ithis.ContainsVertex(edge.Source) || !ithis.ContainsEdge(edge)));
Contract.Ensures(ithis.EdgeCount == Contract.OldValue(ithis.EdgeCount) + (Contract.Result <bool>() ? 1 : 0));
return(default(bool));
}
/// <summary>
/// Computes the incremental connected components for a growing graph (edge added only).
/// Each call to the delegate re-computes the component dictionary. The returned dictionary
/// is shared accross multiple calls of the method.
/// </summary>
/// <typeparam name="TVertex">type of the vertices</typeparam>
/// <typeparam name="TEdge">type of the edges</typeparam>
/// <param name="g"></param>
/// <returns></returns>
public static Func <KeyValuePair <int, IDictionary <TVertex, int> > > IncrementalConnectedComponents <TVertex, TEdge>(
IMutableVertexAndEdgeSet <TVertex, TEdge> g)
where TEdge : IEdge <TVertex>
{
Contract.Requires(g != null);
var incrementalComponents = new IncrementalConnectedComponentsAlgorithm <TVertex, TEdge>(g);
incrementalComponents.Compute();
return(() => incrementalComponents.GetComponents());
}
/// <summary>
/// Initializes a new instance of the <see cref="BipartiteToMaximumFlowGraphAugmentorAlgorithm{TVertex,TEdge}"/> class.
/// </summary>
/// <param name="host">Host to use if set, otherwise use this reference.</param>
/// <param name="visitedGraph">Graph to visit.</param>
/// <param name="sourceToVertices">Vertices to which creating augmented edge from super source.</param>
/// <param name="verticesToSink">Vertices from which creating augmented edge to super sink.</param>
/// <param name="vertexFactory">Vertex factory method.</param>
/// <param name="edgeFactory">Edge factory method.</param>
public BipartiteToMaximumFlowGraphAugmentorAlgorithm(
[CanBeNull] IAlgorithmComponent host,
[NotNull] IMutableVertexAndEdgeSet <TVertex, TEdge> visitedGraph,
[NotNull, ItemNotNull] IEnumerable <TVertex> sourceToVertices,
[NotNull, ItemNotNull] IEnumerable <TVertex> verticesToSink,
[NotNull] VertexFactory <TVertex> vertexFactory,
[NotNull] EdgeFactory <TVertex, TEdge> edgeFactory)
: base(host, visitedGraph, vertexFactory, edgeFactory)
{
SourceToVertices = sourceToVertices ?? throw new ArgumentNullException(nameof(sourceToVertices));
VerticesToSink = verticesToSink ?? throw new ArgumentNullException(nameof(verticesToSink));
}
public BipartiteToMaximumFlowGraphAugmentorAlgorithm(
IAlgorithmComponent host,
IMutableVertexAndEdgeSet <TVertex, TEdge> visitedGraph,
IEnumerable <TVertex> vertexSetA,
IEnumerable <TVertex> vertexSetB,
VertexFactory <TVertex> vertexFactory,
EdgeFactory <TVertex, TEdge> edgeFactory
)
: base(host, visitedGraph, vertexFactory, edgeFactory)
{
this.VertexSetA = vertexSetA;
this.VertexSetB = vertexSetB;
}
protected static void InEdge_ImmutableGraph_ReversedTest(
IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
Func <IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
{
var edge11 = new Edge <int>(1, 1);
var edge31 = new Edge <int>(3, 1);
var edge32 = new Edge <int>(3, 2);
var edge34 = new Edge <int>(3, 4);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge11, edge31, edge32, edge34 });
IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();
AssertSameReversedEdge(edge11, graph.InEdge(1, 0));
AssertSameReversedEdge(edge31, graph.InEdge(3, 0));
AssertSameReversedEdge(edge34, graph.InEdge(3, 2));
}
