/// <summary>Constructs a maximum flow algorithm.</summary>
/// <param name="g">Graph to compute maximum flow on.</param>
/// <param name="capacities">edge capacities</param>
/// <param name="reversedEdges">reversed edge map</param>
/// <exception cref="ArgumentNullException"><paramref name="g"/> or
/// <paramref name="capacities"/> or <paramref name="reversedEdges"/> is a null
/// reference.
/// </exception>
public MaximumFlowAlgorithm(
IVertexListGraph g,
EdgeDoubleDictionary capacities,
EdgeEdgeDictionary reversedEdges
)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
if (capacities == null)
{
throw new ArgumentNullException("capacities");
}
if (reversedEdges == null)
{
throw new ArgumentNullException("reversedEdges");
}
this.visitedGraph = g;
this.capacities = capacities;
this.reversedEdges = reversedEdges;
this.predecessors = new VertexEdgeDictionary();
this.residualCapacities = new EdgeDoubleDictionary();
this.colors = new VertexColorDictionary();
}
/// <inheritdoc />
public int RemoveVertexIf(VertexPredicate <TVertex> predicate)
{
if (predicate is null)
{
throw new ArgumentNullException(nameof(predicate));
}
var verticesToRemove = new VertexList <TVertex>();
verticesToRemove.AddRange(Vertices.Where(vertex => predicate(vertex)));
// Remove out edges
var verticesEdgesRemoved = new VertexEdgeDictionary <TVertex, TEdge>(verticesToRemove.Count);
foreach (TVertex vertex in verticesToRemove)
{
verticesEdgesRemoved[vertex] = _vertexEdges[vertex];
_vertexEdges.Remove(vertex);
}
EdgeCount -= verticesEdgesRemoved.Sum(pair => pair.Value.Count);
Debug.Assert(EdgeCount >= 0);
// Remove in edges (Run over edges and remove each edge touching vertices to remove)
RemoveInEdges(v => verticesToRemove.Contains(v, EqualityComparer <TVertex> .Default));
NotifyEdgesRemoved(verticesEdgesRemoved.Values.SelectMany(edges => edges));
NotifyVerticesRemoved(verticesToRemove);
return(verticesToRemove.Count);
}
public void Clone()
{
var dictionary = new VertexEdgeDictionary <int, EquatableEdge <int> >();
VertexEdgeDictionary <int, EquatableEdge <int> > clonedDictionary = dictionary.Clone();
CollectionAssert.IsEmpty(clonedDictionary);
clonedDictionary = (VertexEdgeDictionary <int, EquatableEdge <int> >)((IVertexEdgeDictionary <int, EquatableEdge <int> >)dictionary).Clone();
CollectionAssert.IsEmpty(clonedDictionary);
clonedDictionary = (VertexEdgeDictionary <int, EquatableEdge <int> >)((ICloneable)dictionary).Clone();
CollectionAssert.IsEmpty(clonedDictionary);
dictionary.Add(1, new EdgeList <int, EquatableEdge <int> > {
new EquatableEdge <int>(1, 2)
});
dictionary.Add(2, new EdgeList <int, EquatableEdge <int> > {
new EquatableEdge <int>(2, 3)
});
dictionary.Add(3, new EdgeList <int, EquatableEdge <int> >());
clonedDictionary = dictionary.Clone();
CollectionAssert.AreEqual(dictionary, clonedDictionary);
clonedDictionary = (VertexEdgeDictionary <int, EquatableEdge <int> >)((IVertexEdgeDictionary <int, EquatableEdge <int> >)dictionary).Clone();
CollectionAssert.AreEqual(dictionary, clonedDictionary);
clonedDictionary = (VertexEdgeDictionary <int, EquatableEdge <int> >)((ICloneable)dictionary).Clone();
CollectionAssert.AreEqual(dictionary, clonedDictionary);
}
public OptimalStrategy(VertexEdgeDictionary successors)
{
if (successors == null)
{
throw new ArgumentNullException("successors");
}
this.successors = successors;
}
/// <summary>
/// Constructor, uses the given predecessor map.
/// </summary>
/// <param name="predecessors">Predecessor map</param>
/// <exception cref="ArgumentNullException">predecessors is null</exception>
public PredecessorRecorderVisitor(VertexEdgeDictionary predecessors)
{
if (predecessors == null)
{
throw new ArgumentNullException("predecessors");
}
m_Predecessors = predecessors;
}
/// <summary>
/// Constructor, uses the given predecessor map.
/// </summary>
/// <param name="predecessors">Predecessor map</param>
/// <exception cref="ArgumentNullException">
/// predecessors is null
/// </exception>
public PredecessorRecorderVisitor(VertexEdgeDictionary predecessors)
{
if (predecessors == null)
{
throw new ArgumentNullException("predecessors");
}
this.predecessors = predecessors;
this.endPathVertices = new VertexCollection();
}
public VertexEdgeDictionary Clone()
{
VertexEdgeDictionary clone = new VertexEdgeDictionary(this.Count);
foreach (KeyValuePair <TVertex, EdgeList> kv in this)
{
clone.Add(kv.Key, kv.Value.Clone());
}
return(clone);
}
public AdjacencyGraph(bool allowParallelEdges, int capacity)
{
this.allowParallelEdges = allowParallelEdges;
if (capacity > 0)
{
this.vertexEdges = new VertexEdgeDictionary(capacity);
}
else
{
this.vertexEdges = new VertexEdgeDictionary();
}
}
private BidirectionalGraph(
VertexEdgeDictionary vertexInEdges,
VertexEdgeDictionary vertexOutEdges,
int edgeCount,
int edgeCapacity,
bool allowParallelEdges
)
{
this.vertexInEdges = vertexInEdges;
this.vertexOutEdges = vertexOutEdges;
this.edgeCount = edgeCount;
this.edgeCapacity = edgeCapacity;
this.allowParallelEdges = allowParallelEdges;
}
public BidirectionalGraph(bool allowParallelEdges, int vertexCapacity)
{
this.allowParallelEdges = allowParallelEdges;
if (vertexCapacity > 0)
{
this.vertexInEdges = new VertexEdgeDictionary(vertexCapacity);
this.vertexOutEdges = new VertexEdgeDictionary(vertexCapacity);
}
else
{
this.vertexInEdges = new VertexEdgeDictionary();
this.vertexOutEdges = new VertexEdgeDictionary();
}
}
public EdmundsKarpMaximumFlow(
Graph g,
EdgeDoubleDictionary edgeCapacities
) : base(g)
{
if (edgeCapacities == null)
{
throw new ArgumentNullException("Edge capacities");
}
m_EdgeCapacities = edgeCapacities;
m_ResidualEdgeCapacities = null;
m_Predecessors = new VertexEdgeDictionary();
}
public AdjacencyGraph(
bool allowParallelEdges,
int capacity,
int edgeCapacity,
Func <int, VertexEdgeDictionary <TVertex, TEdge> > vertexEdgesDictionaryFactory)
{
if (vertexEdgesDictionaryFactory == null)
{
throw new ArgumentNullException("vertexComparer");
}
this.allowParallelEdges = allowParallelEdges;
this.vertexEdges = vertexEdgesDictionaryFactory(capacity);
this.edgeCapacity = edgeCapacity;
}
/// <summary>
/// Initializes a new instance of the <see cref="BidirectionalGraph{TVertex,TEdge}"/> class.
/// </summary>
/// <param name="allowParallelEdges">Indicates if parallel edges are allowed.</param>
/// <param name="vertexCapacity">Vertex capacity.</param>
public BidirectionalGraph(bool allowParallelEdges, int vertexCapacity)
{
AllowParallelEdges = allowParallelEdges;
if (vertexCapacity > -1)
{
_vertexInEdges = new VertexEdgeDictionary <TVertex, TEdge>(vertexCapacity);
_vertexOutEdges = new VertexEdgeDictionary <TVertex, TEdge>(vertexCapacity);
}
else
{
_vertexInEdges = new VertexEdgeDictionary <TVertex, TEdge>();
_vertexOutEdges = new VertexEdgeDictionary <TVertex, TEdge>();
}
}
public UndirectedGraph(bool allowParallelEdges, EdgeEqualityComparer <TVertex, TEdge> edgeEqualityComparer, int vertexCapacity, IEqualityComparer <TVertex> vertexComparer)
{
Contract.Requires(edgeEqualityComparer != null);
Contract.Requires(vertexComparer != null);
this.allowParallelEdges = allowParallelEdges;
this.edgeEqualityComparer = edgeEqualityComparer;
if (vertexCapacity > -1)
{
this.adjacentEdges = new VertexEdgeDictionary <TVertex, TEdge>(vertexCapacity, vertexComparer);
}
else
{
this.adjacentEdges = new VertexEdgeDictionary <TVertex, TEdge>(vertexComparer);
}
}
private UndirectedGraph(
VertexEdgeDictionary <TVertex, TEdge> adjacentEdges,
EdgeEqualityComparer <TVertex, TEdge> edgeEqualityComparer,
int edgeCount,
int edgeCapacity,
bool allowParallelEdges
)
{
Contract.Requires(adjacentEdges != null);
Contract.Requires(edgeEqualityComparer != null);
Contract.Requires(edgeCount >= 0);
this.adjacentEdges = adjacentEdges;
this.edgeEqualityComparer = edgeEqualityComparer;
this.edgeCount = edgeCount;
this.edgeCapacity = edgeCapacity;
this.allowParallelEdges = allowParallelEdges;
}
private UndirectedGraph(
[NotNull] VertexEdgeDictionary <TVertex, TEdge> adjacentEdges,
[NotNull] EdgeEqualityComparer <TVertex> edgeEqualityComparer,
int edgeCount,
int edgeCapacity,
bool allowParallelEdges)
{
if (edgeCount < 0)
{
throw new ArgumentException("Must be positive", nameof(edgeCount));
}
_adjacentEdges = adjacentEdges ?? throw new ArgumentNullException(nameof(adjacentEdges));
EdgeEqualityComparer = edgeEqualityComparer ?? throw new ArgumentNullException(nameof(edgeEqualityComparer));
EdgeCount = edgeCount;
EdgeCapacity = edgeCapacity;
AllowParallelEdges = allowParallelEdges;
}
public AdjacencyGraph(bool allowParallelEdges, int vertexCapacity, int edgeCapacity, IEqualityComparer <TVertex> vertexComparer)
{
if (vertexComparer == null)
{
throw new ArgumentNullException("vertexComparer");
}
this.allowParallelEdges = allowParallelEdges;
if (vertexCapacity > -1)
{
this.vertexEdges = new VertexEdgeDictionary <TVertex, TEdge>(vertexCapacity, vertexComparer);
}
else
{
this.vertexEdges = new VertexEdgeDictionary <TVertex, TEdge>(vertexComparer);
}
this.edgeCapacity = edgeCapacity;
}
public void Serialization()
{
var dictionary = new VertexEdgeDictionary <int, EquatableEdge <int> >();
VertexEdgeDictionary <int, EquatableEdge <int> > deserializedDictionary = SerializeAndDeserialize(dictionary);
Assert.AreNotSame(dictionary, deserializedDictionary);
CollectionAssert.IsEmpty(deserializedDictionary);
dictionary.Add(1, new EdgeList <int, EquatableEdge <int> > {
new EquatableEdge <int>(1, 2)
});
dictionary.Add(2, new EdgeList <int, EquatableEdge <int> > {
new EquatableEdge <int>(2, 3)
});
deserializedDictionary = SerializeAndDeserialize(dictionary);
Assert.AreNotSame(dictionary, deserializedDictionary);
CollectionAssert.AreEqual(dictionary, deserializedDictionary);
}
public void GenerateWalls(int outi, int outj, int ini, int inj)
{
// here we use a uniform probability distribution among the out-edges
CyclePoppingRandomTreeAlgorithm pop =
new CyclePoppingRandomTreeAlgorithm(this.graph);
// we can also weight the out-edges
/*
* EdgeDoubleDictionary weights = new EdgeDoubleDictionary();
* foreach(IEdge e in this.graph.Edges)
* weights[e]=1;
* pop.EdgeChain = new WeightedMarkovEdgeChain(weights);
*/
IVertex root = this.latice[outi, outj];
if (root == null)
{
throw new ArgumentException("outi,outj vertex not found");
}
pop.RandomTreeWithRoot(this.latice[outi, outj]);
this.successors = pop.Successors;
// build the path to ini, inj
IVertex v = this.latice[ini, inj];
if (v == null)
{
throw new ArgumentException("ini,inj vertex not found");
}
this.outPath = new EdgeCollection();
while (v != root)
{
IEdge e = this.successors[v];
if (e == null)
{
throw new Exception();
}
this.outPath.Add(e);
v = e.Target;
}
}
internal void Augment(Vertex src, Vertex sink, VertexEdgeDictionary predecessors)
{
// find minimum residual capacity along the augmenting path
double delta = double.MaxValue;
Edge e = predecessors[sink];
Vertex u = null;
do
{
delta = Math.Min(delta, ResidualEdgeCapacities[e]);
u = e.Source;
e = predecessors[u];
} while (u != src);
// push delta units of flow along the augmenting path
e = predecessors[sink];
do
{
ResidualEdgeCapacities[e] -= delta;
ResidualEdgeCapacities[ReverseEdges[e]] += delta;
u = e.Source;
e = predecessors[u];
} while (u != src);
}
/// <summary>
/// Default constructor
/// </summary>
public PredecessorRecorderVisitor()
{
m_Predecessors = new VertexEdgeDictionary();
}
public XUndirectedGraph(bool allowParallelEdges, EdgeEqualityComparer <TVertex, TEdge> edgeEqualityComparer)
{
AllowParallelEdges = allowParallelEdges;
_edgeEqualityComparer = edgeEqualityComparer;
_adjacentEdges = new VertexEdgeDictionary <TVertex, TEdge>();
}
/// <summary>
/// Default constructor
/// </summary>
public PredecessorRecorderVisitor()
{
this.predecessors = new VertexEdgeDictionary();
this.endPathVertices = new VertexCollection();
}
