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; }