public void RemoveEdgeIf(IMutableEdgeListGraph g)
{
if (g.EdgesEmpty)
return;
IEdge e = RandomGraph.Edge(g,Rnd);
g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e,false));
g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e,true));
}
bool IMutableEdgeListGraph <TVertex, TEdge> .RemoveEdge(TEdge e)
{
IMutableEdgeListGraph <TVertex, TEdge> ithis = this;
//Contract.Requires(e != null);
//Contract.Ensures(//Contract.Result<bool>() == //Contract.OldValue(ithis.ContainsEdge(e)));
//Contract.Ensures(!ithis.ContainsEdge(e));
//Contract.Ensures(ithis.EdgeCount == //Contract.OldValue(ithis.EdgeCount) - (//Contract.Result<bool>() ? 1 : 0));
return(default(bool));
}
int IMutableEdgeListGraph <TVertex, TEdge> .RemoveEdgeIf(EdgePredicate <TVertex, TEdge> predicate)
{
IMutableEdgeListGraph <TVertex, TEdge> ithis = this;
Contract.Requires(predicate != null);
Contract.Ensures(Contract.Result <int>() == Contract.OldValue(Enumerable.Count(ithis.Edges, e => predicate(e))));
Contract.Ensures(Enumerable.All(ithis.Edges, e => !predicate(e)));
Contract.Ensures(ithis.EdgeCount == Contract.OldValue(ithis.EdgeCount) - Contract.Result <int>());
return(default(int));
}
public void RemoveEdgeIf(IMutableEdgeListGraph g)
{
if (g.EdgesEmpty)
{
return;
}
IEdge e = RandomGraph.Edge(g, Rnd);
g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e, false));
g.RemoveEdgeIf(new DummyEdgeEqualPredicate(e, true));
}
bool IMutableEdgeListGraph <TVertex, TEdge> .AddEdge(TEdge e)
{
IMutableEdgeListGraph <TVertex, TEdge> ithis = this;
Contract.Requires(e != null);
Contract.Requires(ithis.ContainsVertex(e.Source));
Contract.Requires(ithis.ContainsVertex(e.Target));
Contract.Ensures(ithis.ContainsEdge(e));
Contract.Ensures(ithis.AllowParallelEdges || Contract.Result <bool>() == Contract.OldValue(!ithis.ContainsEdge(e)));
Contract.Ensures(ithis.EdgeCount == Contract.OldValue(ithis.EdgeCount) + (Contract.Result <bool>() ? 1 : 0));
return(default(bool));
}
protected static void ContainsEdge_EquatableEdges_ForbiddenParallelEdges_ImmutableVertices_Test(
[NotNull] IMutableEdgeListGraph <int, EquatableEdge <int> > graph)
{
var edge1 = new EquatableEdge <int>(1, 2);
var edge2 = new EquatableEdge <int>(1, 3);
var edge3 = new EquatableEdge <int>(2, 1);
var edge4 = new EquatableEdge <int>(2, 2);
var otherEdge1 = new EquatableEdge <int>(1, 2);
Assert.IsFalse(graph.ContainsEdge(edge1));
Assert.IsFalse(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsFalse(graph.ContainsEdge(otherEdge1));
graph.AddEdge(edge1);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsFalse(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddEdge(edge2);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddEdge(edge3);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddEdge(edge4);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsTrue(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
// Both vertices not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(10, 11)));
// Source not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(10, 1)));
// Target not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(1, 10)));
}
int IMutableEdgeListGraph <TVertex, TEdge> .AddEdgeRange(IEnumerable <TEdge> edges)
{
IMutableEdgeListGraph <TVertex, TEdge> ithis = this;
Contract.Requires(edges != null);
Contract.Requires(typeof(TEdge).IsValueType || Enumerable.All(edges, edge => edge != null));
Contract.Requires(Enumerable.All(edges, edge =>
ithis.ContainsVertex(edge.Source) &&
ithis.ContainsVertex(edge.Target)
));
Contract.Ensures(Enumerable.All(edges, edge => ithis.ContainsEdge(edge)), "all edge from edges belong to the graph");
Contract.Ensures(
Contract.Result <int>() == Contract.OldValue(Enumerable.Count(edges, edge => !ithis.ContainsEdge(edge))));
Contract.Ensures(ithis.EdgeCount == Contract.OldValue(ithis.EdgeCount) + Contract.Result <int>());
return(default(int));
}
void AddFallbackEdges(IMutableEdgeListGraph<AutoMixingBucket, AutoMixEdge> graph)
{
AddEdges(graph, strategiesFactory.GetNonPreferredCompatibleStrategies());
Log.DebugFormat("Added {0} fallback edges (harmonic but not preferred).", graph.EdgeCount);
}
void AddPreferredEdges(IMutableEdgeListGraph<AutoMixingBucket, AutoMixEdge> graph)
{
AddEdges(graph, strategiesFactory.GetPreferredStrategiesInOrder());
Log.DebugFormat("Added {0} preferred edges.", graph.EdgeCount);
}
/// <summary>
/// Add any graph edge where there is any transition from one track to
/// another, using one of the specified mixing strategies.
/// </summary>
void AddEdges(IMutableEdgeListGraph<AutoMixingBucket, AutoMixEdge> graph,
IEnumerable<IMixingStrategy> strategies)
{
IEnumerable<AutoMixEdge> edges =
from preceedingTrack in graph.Vertices
from followingTrack in graph.Vertices
where !followingTrack.Equals(preceedingTrack)
from strategy in strategies
where strategy.IsCompatible(preceedingTrack.ActualKey, followingTrack.ActualKey)
orderby followingTrack.ActualKey, preceedingTrack.ActualKey
let cost = edgeCostCalculator.CalculateCost(strategy)
select new AutoMixEdge(preceedingTrack, followingTrack, strategy, cost);
graph.AddEdgeRange(edges);
}
