public bool TryGetSuccessor(IImplicitGraph <TVertex, TEdge> g, TVertex u, out TEdge successor)
{
Contract.Requires(g != null);
Contract.Requires(u != null);
int outDegree = g.OutDegree(u);
if (outDegree > 0)
{
int index;
if (!outEdgeIndices.TryGetValue(u, out index))
{
index = 0;
outEdgeIndices.Add(u, index);
}
TEdge e = g.OutEdge(u, index);
this.outEdgeIndices[u] = (++index) % outDegree;
successor = e;
return(true);
}
successor = default(TEdge);
return(false);
}
protected static void TryGetOutEdges_ImmutableGraph_ReversedTest(
[NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
[NotNull, InstantHandle] 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);
}
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);
}
protected static void TryGetOutEdges_Test(
[NotNull] IImplicitGraph <int, Edge <int> > graph,
[NotNull, InstantHandle] Action <IEnumerable <Edge <int> > > addVerticesAndEdgeRange)
{
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);
addVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
Assert.IsFalse(graph.TryGetOutEdges(0, out _));
Assert.IsTrue(graph.TryGetOutEdges(5, out IEnumerable <Edge <int> > gotEdges));
CollectionAssert.IsEmpty(gotEdges);
Assert.IsTrue(graph.TryGetOutEdges(3, out gotEdges));
CollectionAssert.AreEqual(new[] { edge6 }, gotEdges);
Assert.IsTrue(graph.TryGetOutEdges(1, out gotEdges));
CollectionAssert.AreEqual(new[] { edge1, edge2, edge3 }, gotEdges);
}
/// <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 override TEdge Successor(IImplicitGraph <TVertex, TEdge> g, TVertex u)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
if (u == null)
{
throw new ArgumentNullException("u");
}
// get number of out-edges
int n = g.OutDegree(u);
if (n == 0)
{
return(default(TEdge));
}
// compute out-edge su
double outWeight = GetOutWeight(g, u);
// scale and get next edge
double r = this.Rand.NextDouble() * outWeight;
return(Successor(g, u, r));
}
public ObjectGraph(Object root, IExplorer explorer)
{
_root = new Vertex(root, 0, 0);
_impl = new TransitionFactoryImplicitGraph <Vertex, Edge> {
TransitionFactories = { explorer }
};
}
protected static void TryGetOutEdges_ImmutableGraph_Test(
IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
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);
}
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);
}
/// <summary>
/// Initializes a new instance of the <see cref="RandomWalkAlgorithm{TVertex,TEdge}"/> class.
/// </summary>
/// <param name="visitedGraph">Graph to visit.</param>
/// <param name="edgeChain">Edge chain strategy to use.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="visitedGraph"/> is <see langword="null"/>.</exception>
/// <exception cref="T:System.ArgumentNullException"><paramref name="edgeChain"/> is <see langword="null"/>.</exception>
public RandomWalkAlgorithm(
[NotNull] IImplicitGraph <TVertex, TEdge> visitedGraph,
[NotNull] IEdgeChain <TVertex, TEdge> edgeChain)
: base(null, visitedGraph)
{
_edgeChain = edgeChain ?? throw new ArgumentNullException(nameof(edgeChain));
}
public virtual IEdge Successor(IImplicitGraph g, IVertex u)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
if (u == null)
{
throw new ArgumentNullException("u");
}
int num = g.OutDegree(u);
double num2 = 0.0;
IEdgeEnumerator enumerator = g.OutEdges(u).GetEnumerator();
while (enumerator.MoveNext())
{
IEdge edge = enumerator.get_Current();
num2 += this.weights.get_Item(edge);
}
double num3 = this.rnd.NextDouble() * num2;
double num4 = 0.0;
double num5 = 0.0;
IEdgeEnumerator enumerator2 = g.OutEdges(u).GetEnumerator();
while (enumerator2.MoveNext())
{
IEdge edge2 = enumerator2.get_Current();
num5 = num4 + this.weights.get_Item(edge2);
if ((num3 >= num4) && (num3 <= num5))
{
return edge2;
}
num4 = num5;
}
return null;
}
/// <summary>
/// Create the predicate over <paramref name="graph"/>.
/// </summary>
/// <param name="graph">graph to visit</param>
public SinkVertexPredicate(IImplicitGraph graph)
{
if (graph == null)
{
throw new ArgumentNullException("graph");
}
this.graph = graph;
}
protected static void TryGetOutEdges_Throws_Test <TVertex, TEdge>(
[NotNull] IImplicitGraph <TVertex, TEdge> graph)
where TVertex : class
where TEdge : IEdge <TVertex>
{
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => graph.TryGetOutEdges(null, out _));
}
public override IEdge Successor(IImplicitGraph g, IVertex u)
{
EdgeDoubleDictionary dictionary;
IEdge edge3;
IEdge edge = base.Successor(g, u);
(dictionary = base.Weights).set_Item(edge3 = edge, dictionary.get_Item(edge3) * this.Factor);
return edge;
}
/// <summary>
/// Tries to get the successor of the given <paramref name="vertex"/> in the given <paramref name="graph"/>.
/// </summary>
/// <param name="graph">The graph to search in.</param>
/// <param name="vertex">The vertex.</param>
/// <param name="position">The position.</param>
/// <param name="successor">Found successor, otherwise null.</param>
/// <returns>True if a successor was found, false otherwise.</returns>
protected bool TryGetSuccessor([NotNull] IImplicitGraph <TVertex, TEdge> graph, [NotNull] TVertex vertex, double position, out TEdge successor)
{
Debug.Assert(graph != null);
Debug.Assert(vertex != null);
IEnumerable <TEdge> edges = graph.OutEdges(vertex);
return(TryGetSuccessor(edges, position, out successor));
}
public override IEdge Successor(IImplicitGraph g, IVertex u)
{
// get succesor
IEdge s = base.Successor(g,u);
// update probabilities
this.Weights[s]*=this.Factor;
return s;
}
protected bool TryGetSuccessor(IImplicitGraph <TVertex, TEdge> g, TVertex u, double position, out TEdge successor)
{
Contract.Requires(g != null);
Contract.Requires(u != null);
var edges = g.OutEdges(u);
return(TryGetSuccessor(edges, position, out successor));
}
protected double GetOutWeight(IImplicitGraph <TVertex, TEdge> g, TVertex u)
{
Contract.Requires(g != null);
Contract.Requires(u != null);
var edges = g.OutEdges(u);
return(GetWeights(edges));
}
protected static void OutEdge_NullThrows_Test <TVertex, TEdge>(
IImplicitGraph <TVertex, TEdge> graph)
where TVertex : class
where TEdge : IEdge <TVertex>
{
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => graph.OutEdge(null, 0));
}
/// <summary>
/// Constructs the algorithm around <paramref name="g"/>.
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="g">visted graph</param>
/// <exception cref="ArgumentNullException">g is a null reference</exception>
public RandomWalkAlgorithm(
IVertexListGraph g)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
this.visitedGraph = g;
}
protected double GetOutWeight(IImplicitGraph <TVertex, TEdge> g, TVertex u)
{
double outWeight = 0;
foreach (TEdge e in g.OutEdges(u))
{
outWeight += this.weights[e];
}
return(outWeight);
}
public override IEdge Successor(IImplicitGraph g, IVertex u)
{
// get succesor
IEdge s = base.Successor(g, u);
// update probabilities
this.Weights[s] *= this.Factor;
return(s);
}
TEdge IImplicitGraph <TVertex, TEdge> .OutEdge(TVertex v, int index)
{
IImplicitGraph <TVertex, TEdge> ithis = this;
Contract.Requires(v != null);
Contract.Requires(ithis.ContainsVertex(v));
Contract.Ensures(Enumerable.Any(ithis.OutEdges(v), e => e.Equals(Contract.Result <TEdge>())));
return(default(TEdge));
}
bool IImplicitGraph <TVertex, TEdge> .IsOutEdgesEmpty(TVertex v)
{
IImplicitGraph <TVertex, TEdge> ithis = this;
//Contract.Requires(v != null);
//Contract.Requires(ithis.ContainsVertex(v));
//Contract.Ensures(//Contract.Result<bool>() == (ithis.OutDegree(v) == 0));
return(default(bool));
}
int IImplicitGraph <TVertex, TEdge> .OutDegree(TVertex v)
{
IImplicitGraph <TVertex, TEdge> ithis = this;
//Contract.Requires(v != null);
//Contract.Requires(ithis.ContainsVertex(v));
//Contract.Ensures(//Contract.Result<int>() == Enumerable.Count<TEdge>(ithis.OutEdges(v)));
return(default(int));
}
int IImplicitGraph <TVertex, TEdge> .OutDegree(TVertex v)
{
IImplicitGraph <TVertex, TEdge> ithis = this;
Contract.Requires(v != null);
Contract.Requires(ithis.ContainsVertex(v));
Contract.Ensures(Contract.Result <int>() == ithis.OutEdges(v).Count());
return(default(int));
}
IEnumerable <TEdge> IImplicitGraph <TVertex, TEdge> .OutEdges(TVertex v)
{
IImplicitGraph <TVertex, TEdge> ithis = this;
//Contract.Requires(v != null);
//Contract.Requires(ithis.ContainsVertex(v));
//Contract.Ensures(//Contract.Result<IEnumerable<TEdge>>() != null);
//Contract.Ensures(Enumerable.All(//Contract.Result<IEnumerable<TEdge>>(), e => e.Source.Equals(v)));
return(default(IEnumerable <TEdge>));
}
public RandomWalkAlgorithm(
IImplicitGraph <TVertex, TEdge> visitedGraph,
IEdgeChain <TVertex, TEdge> edgeChain
)
{
Contract.Requires(visitedGraph != null);
Contract.Requires(edgeChain != null);
this.visitedGraph = visitedGraph;
this.edgeChain = edgeChain;
}
public RandomWalkAlgorithm(IVertexListGraph g)
{
this.visitedGraph = null;
this.endPredicate = null;
this.edgeChain = new NormalizedMarkovEdgeChain();
this.rnd = new Random((int) DateTime.Now.Ticks);
if (g == null)
{
throw new ArgumentNullException("g");
}
this.visitedGraph = g;
}
TEdge IImplicitGraph <TVertex, TEdge> .OutEdge(TVertex v, int index)
{
IImplicitGraph <TVertex, TEdge> ithis = this;
//Contract.Requires(v != null);
//Contract.Requires(ithis.ContainsVertex(v));
//Contract.Requires(index >= 0 && index < ithis.OutDegree(v));
//Contract.Ensures(
// Enumerable.ElementAt(ithis.OutEdges(v), index).Equals(//Contract.Result<TEdge>()));
return(default(TEdge));
}
public IEdge Successor(IImplicitGraph g, IVertex u)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
if (u == null)
{
throw new ArgumentNullException("u");
}
return this.NextState(g.OutDegree(u), g.OutEdges(u));
}
bool IImplicitGraph <TVertex, TEdge> .TryGetOutEdges(TVertex v, out IEnumerable <TEdge> edges)
{
IImplicitGraph <TVertex, TEdge> ithis = this;
//Contract.Requires(v != null);
//Contract.Ensures(!//Contract.Result<bool>() ||
// (//Contract.ValueAtReturn(out edges) != null &&
// Enumerable.All(//Contract.ValueAtReturn(out edges), e => e.Source.Equals(v)))
// );
edges = null;
return(default(bool));
}
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
}
/// <summary>
/// Constructs the algorithm around <paramref name="g"/>.
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="g">visted graph</param>
/// <exception cref="ArgumentNullException">g is a null reference</exception>
public RandomWalkAlgorithm(
IVertexListGraph g)
{
if (g==null)
throw new ArgumentNullException("g");
this.visitedGraph = g;
}
/// <summary>
/// Selects the next out-<see cref="IEdge"/> in the Markov Chain.
/// </summary>
/// <param name="g">visted graph</param>
/// <param name="u">source vertex</param>
/// <returns>Random next out-edge</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="g"/> or <paramref name="u"/> is a null reference
/// </exception>
public virtual IEdge Successor(IImplicitGraph g, IVertex u)
{
if (g==null)
throw new ArgumentNullException("g");
if (u==null)
throw new ArgumentNullException("u");
// get number of out-edges
int n = g.OutDegree(u);
// compute out-edge su
double outWeight = 0;
foreach(IEdge e in g.OutEdges(u))
{
outWeight+=this.weights[e];
}
// scale and get next edge
double r = rnd.NextDouble() * outWeight;
double pos = 0;
double nextPos = 0;
foreach(IEdge e in g.OutEdges(u))
{
nextPos = pos+this.weights[e];
if (r>=pos && r<=nextPos)
return e;
pos = nextPos;
}
return null;
}
public ObjectGraph(Object root, IExplorer explorer)
{
_root = new Vertex(root, 0, 0);
_impl = new TransitionFactoryImplicitGraph<Vertex, Edge>{TransitionFactories = {explorer}};
}
public static SinkVertexPredicate SinkVertex(IImplicitGraph graph)
{
return new SinkVertexPredicate(graph);
}
/// <summary>
/// Create the predicate over <paramref name="graph"/>.
/// </summary>
/// <param name="graph">graph to visit</param>
public SinkVertexPredicate(IImplicitGraph graph)
{
if (graph == null)
throw new ArgumentNullException("graph");
this.graph = graph;
}
/// <summary>
/// Constructs the algorithm around <paramref name="g"/> using
/// the <paramref name="edgeChain"/> Markov chain.
/// </summary>
/// <param name="g">visited graph</param>
/// <param name="edgeChain">
/// Markov <see cref="IEdge"/> chain generator
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="g"/> or <paramref name="edgeChain"/>
/// is a null reference
/// </exception>
public RandomWalkAlgorithm(
IVertexListGraph g,
IMarkovEdgeChain edgeChain
)
{
if (g==null)
throw new ArgumentNullException("g");
if (edgeChain == null)
throw new ArgumentNullException("edgeChain");
this.visitedGraph = g;
this.edgeChain = edgeChain;
}
