/// <inheritdoc />
public override bool TryGetSuccessor(IImplicitGraph <TVertex, TEdge> graph, TVertex vertex, out TEdge successor)
{
if (!graph.IsOutEdgesEmpty(vertex))
{
// Get out weight
double outWeight = GetOutWeight(graph, vertex);
// Get successor
if (TryGetSuccessor(graph, vertex, Rand.NextDouble() * outWeight, out successor))
{
// Update probabilities
Weights[successor] *= Factor;
// Normalize
foreach (TEdge edge in graph.OutEdges(vertex))
{
Weights[edge] /= outWeight;
}
return(true);
}
}
successor = default(TEdge);
return(false);
}
public static void AssertNoOutEdge <TVertex, TEdge>(IImplicitGraph <TVertex, TEdge> graph, TVertex vertex)
where TEdge : IEdge <TVertex>
{
Assert.IsTrue(graph.IsOutEdgesEmpty(vertex));
Assert.AreEqual(0, graph.OutDegree(vertex));
CollectionAssert.IsEmpty(graph.OutEdges(vertex));
}
public override bool TryGetSuccessor(IImplicitGraph <TVertex, TEdge> g, TVertex u, out TEdge successor)
{
if (!g.IsOutEdgesEmpty(u))
{
// get outweight
double outWeight = GetOutWeight(g, u);
// get succesor
TEdge s;
if (this.TryGetSuccessor(g, u, this.Rand.NextDouble() * outWeight, out s))
{
// update probabilities
this.Weights[s] *= this.Factor;
// normalize
foreach (TEdge e in g.OutEdges(u))
{
checked
{
this.Weights[e] /= outWeight;
}
}
successor = s;
return(true);
}
}
successor = default(TEdge);
return(false);
}
public override TEdge Successor(IImplicitGraph <TVertex, TEdge> g, TVertex u)
{
if (g.IsOutEdgesEmpty(u))
{
return(default(TEdge));
}
// get outweight
double outWeight = GetOutWeight(g, u);
// get succesor
TEdge s = Successor(g, u, this.Rand.NextDouble() * outWeight);
// update probabilities
this.Weights[s] *= this.Factor;
// normalize
foreach (TEdge e in g.OutEdges(u))
{
checked
{
this.Weights[e] /= outWeight;
}
}
return(s);
}
public static void AssertHasOutEdges <TVertex, TEdge>(
IImplicitGraph <TVertex, TEdge> graph,
TVertex vertex,
IEnumerable <TEdge> edges)
where TEdge : IEdge <TVertex>
{
TEdge[] edgeArray = edges.ToArray();
CollectionAssert.IsNotEmpty(edgeArray);
Assert.IsFalse(graph.IsOutEdgesEmpty(vertex));
Assert.AreEqual(edgeArray.Length, graph.OutDegree(vertex));
CollectionAssert.AreEquivalent(edgeArray, graph.OutEdges(vertex));
}
protected static void OutEdges_NullThrows_Test <TVertex, TEdge>(
IImplicitGraph <TVertex, TEdge> graph)
where TVertex : class
where TEdge : IEdge <TVertex>
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
// ReSharper disable AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => graph.IsOutEdgesEmpty(null));
Assert.Throws <ArgumentNullException>(() => graph.OutDegree(null));
Assert.Throws <ArgumentNullException>(() => graph.OutEdges(null).ToArray());
// ReSharper restore AssignNullToNotNullAttribute
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
}
/// <inheritdoc />
public override bool TryGetSuccessor(IImplicitGraph <TVertex, TEdge> graph, TVertex vertex, out TEdge successor)
{
if (!graph.IsOutEdgesEmpty(vertex))
{
// Compute out-edge su
double outWeight = GetOutWeight(graph, vertex);
// Scale and get next edge
double random = Rand.NextDouble() * outWeight;
return(TryGetSuccessor(graph, vertex, random, out successor));
}
successor = default(TEdge);
return(false);
}
protected static void OutEdges_Throws_Test <TVertex, TEdge>(
IImplicitGraph <TVertex, TEdge> graph)
where TVertex : IEquatable <TVertex>, new()
where TEdge : IEdge <TVertex>
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
// ReSharper disable AssignNullToNotNullAttribute
var vertex = new TVertex();
Assert.Throws <VertexNotFoundException>(() => graph.IsOutEdgesEmpty(vertex));
Assert.Throws <VertexNotFoundException>(() => graph.OutDegree(vertex));
Assert.Throws <VertexNotFoundException>(() => graph.OutEdges(vertex).ToArray());
// ReSharper restore AssignNullToNotNullAttribute
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
}
public static void AssertHasReversedOutEdges <TVertex, TEdge>(
[NotNull] IImplicitGraph <TVertex, SReversedEdge <TVertex, TEdge> > graph,
[NotNull] TVertex vertex,
[NotNull, ItemNotNull] IEnumerable <TEdge> edges)
where TEdge : IEdge <TVertex>
{
TEdge[] edgeArray = edges.ToArray();
CollectionAssert.IsNotEmpty(edgeArray);
Assert.IsFalse(graph.IsOutEdgesEmpty(vertex));
Assert.AreEqual(edgeArray.Length, graph.OutDegree(vertex));
CollectionAssert.AreEquivalent(
edgeArray.Select(edge => new SReversedEdge <TVertex, TEdge>(edge)),
graph.OutEdges(vertex));
}
protected static void OutEdges_Throws_Test(
[NotNull] GraphData <int, Edge <int> > data,
[NotNull] IImplicitGraph <int, Edge <int> > graph)
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
data.CheckCalls(0);
data.ShouldReturnValue = false;
Assert.Throws <VertexNotFoundException>(() => graph.IsOutEdgesEmpty(1));
data.CheckCalls(1);
Assert.Throws <VertexNotFoundException>(() => graph.OutDegree(1));
data.CheckCalls(1);
Assert.Throws <VertexNotFoundException>(() => graph.OutEdges(1));
data.CheckCalls(1);
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
}
public bool IsOutEdgesEmpty(Vertex v)
{
return(_impl.IsOutEdgesEmpty(v));
}
