public static bool VertexCountEqual <TVertex>(this IVertexSet <TVertex> left, IVertexSet <TVertex> right) { Contract.Requires(left != null); Contract.Requires(right != null); return(left.VertexCount == right.VertexCount); }
/// <summary> /// Gets the vertex identity. /// </summary> /// <remarks> /// Returns more efficient methods for primitive types, /// otherwise builds a dictionary /// </remarks> /// <typeparam name="TVertex">The type of the vertex.</typeparam> /// <param name="graph">The graph.</param> /// <returns></returns> public static VertexIdentity <TVertex> GetVertexIdentity <TVertex>( #if !NET20 this #endif IVertexSet <TVertex> graph) { Contract.Requires(graph != null); // simpler identity for primitive types var type = typeof(TVertex); if (type == typeof(Boolean) || (type == typeof(Byte)) || (type == typeof(Char)) || (type == typeof(UInt16)) || (type == typeof(UInt32)) || (type == typeof(UInt64)) || (type == typeof(SByte)) || (type == typeof(Int16)) || (type == typeof(Int32)) || (type == typeof(Int64)) || (type == typeof(String)) || (type == typeof(Single)) || (type == typeof(Double)) || (type == typeof(DateTime)) || (type == (typeof(Decimal)))) { return((v) => v.ToString()); } // create dictionary var ids = new Dictionary <TVertex, string>(graph.VertexCount); return(v => { string id; if (!ids.TryGetValue(v, out id)) { ids[v] = id = ids.Count.ToString(); } return id; }); }
public static void AssertVertexCountEqual <TVertex>( this IVertexSet <TVertex> left, IVertexSet <TVertex> right) { Assert.IsNotNull(left); Assert.IsNotNull(right); Assert.AreEqual(left.VertexCount, right.VertexCount); }
public static bool InVertexSet <TVertex>( this IVertexSet <TVertex> g, TVertex v) { Contract.Requires(g != null); Contract.Requires(v != null); // todo make requires return(g.ContainsVertex(v)); }
private static void CheckComponentCount<TVertex, TEdge>( [NotNull] IVertexListGraph<TVertex, TEdge> graph, [NotNull] IVertexSet<AdjacencyGraph<TVertex, TEdge>> condensedGraph) where TEdge : IEdge<TVertex> { // Check number of vertices = number of strongly connected components int components = graph.WeaklyConnectedComponents(new Dictionary<TVertex, int>()); Assert.AreEqual(components, condensedGraph.VertexCount, "Component count does not match."); }
protected static void AddVertex_ImmutableGraph_WithUpdate( IMutableVertexSet <int> wrappedGraph, Func <IVertexSet <int> > createGraph) { IVertexSet <int> graph = createGraph(); wrappedGraph.AddVertex(1); AssertHasVertices(graph, new[] { 1 }); // Graph is updated }
protected static void AddVertex_ImmutableGraph_NoUpdate( IMutableVertexSet <int> wrappedGraph, Func <IVertexSet <int> > createGraph) { IVertexSet <int> graph = createGraph(); wrappedGraph.AddVertex(1); AssertNoVertex(graph); // Graph is not updated }
public static TVertex GetVertex <TVertex>( [NotNull] IVertexSet <TVertex> graph, [NotNull] Random rng) { if (graph is null) { throw new ArgumentNullException(nameof(graph)); } return(GetVertex(graph.Vertices, graph.VertexCount, rng)); }
protected static void CheckComponentCount <TVertex, TEdge>( IVertexListGraph <TVertex, TEdge> graph, IVertexSet <AdjacencyGraph <TVertex, TEdge> > condensedGraph) where TEdge : IEdge <TVertex> { // Check number of vertices = number of strongly connected components var components = new Dictionary <TVertex, int>(); int componentCount = graph.StronglyConnectedComponents(components); Assert.AreEqual(componentCount, condensedGraph.VertexCount, "Component count does not match."); }
private static void VerifyVertexCount <TVertex, TEdge>( [NotNull] IVertexSet <TVertex> graph, // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local [NotNull] MultiSourceSinkGraphAugmentorAlgorithm <TVertex, TEdge> augmentor, int vertexCount) where TEdge : IEdge <TVertex> { Assert.AreEqual(vertexCount + 2 /* Source + Sink */, graph.VertexCount); Assert.IsTrue(graph.ContainsVertex(augmentor.SuperSource)); Assert.IsTrue(graph.ContainsVertex(augmentor.SuperSink)); }
public static void AssertHasVertices <TVertex>( IVertexSet <TVertex> graph, IEnumerable <TVertex> vertices) { TVertex[] vertexArray = vertices.ToArray(); CollectionAssert.IsNotEmpty(vertexArray); Assert.IsFalse(graph.IsVerticesEmpty); Assert.AreEqual(vertexArray.Length, graph.VertexCount); CollectionAssert.AreEquivalent(vertexArray, graph.Vertices); }
public static void AssumeInVertexSet <TVertex>( IVertexSet <TVertex> g, TVertex v, string parameterName) { AssumeNotNull(g, "g"); AssumeNotNull(v, parameterName); if (!g.ContainsVertex(v)) { throw new VertexNotFoundException(parameterName); } }
public static void AssumeNotInVertexSet <TVertex>( IVertexSet <TVertex> g, TVertex v, string parameterName) { AssumeNotNull(g, "g"); AssumeNotNull(v, parameterName); if (g.ContainsVertex(v)) { throw new ArgumentException("vertex already in set", parameterName); } }
public static bool VertexCountEqual <TVertex>( #if !NET20 this #endif IVertexSet <TVertex> left, IVertexSet <TVertex> right) { //Contract.Requires(left != null); //Contract.Requires(right != null); return(left.VertexCount == right.VertexCount); }
protected static void CheckVertexCount <TVertex, TEdge>( IVertexSet <TVertex> graph, IVertexSet <AdjacencyGraph <TVertex, TEdge> > condensedGraph) where TEdge : IEdge <TVertex> { int count = 0; foreach (AdjacencyGraph <TVertex, TEdge> vertices in condensedGraph.Vertices) { count += vertices.VertexCount; } Assert.AreEqual(graph.VertexCount, count, $"{nameof(graph.VertexCount)} does not match."); }
private void Check(IVertexSet <IGeometry> graph, IDictionary <IEdge <IGeometry>, double> consts, VertexPredecessorRecorderObserver <IGeometry, IEdge <IGeometry> > predecessorObserver) { foreach (IGeometry v in graph.Vertices) { double distance = 0; IGeometry vertex = v; IEdge <IGeometry> predecessor; while (predecessorObserver.VertexPredecessors.TryGetValue(vertex, out predecessor)) { distance += consts[predecessor]; vertex = predecessor.Source; } Console.WriteLine("A -> {0}: {1}", v, distance); } }
/// <summary> /// Gets the vertex identity. /// </summary> /// <remarks> /// Returns more efficient methods for primitive types, /// otherwise builds a dictionary /// </remarks> /// <typeparam name="TVertex">The type of the vertex.</typeparam> /// <param name="graph">The graph.</param> /// <returns></returns> public static VertexIdentity <TVertex> GetVertexIdentity <TVertex>( #if !NET20 this #endif IVertexSet <TVertex> graph) { Contract.Requires(graph != null); // simpler identity for primitive types switch (Type.GetTypeCode(typeof(TVertex))) { case TypeCode.String: case TypeCode.Boolean: case TypeCode.Byte: case TypeCode.Char: case TypeCode.Decimal: case TypeCode.Double: case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.SByte: case TypeCode.Single: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: return((v) => v.ToString()); } // create dictionary var ids = new Dictionary <TVertex, string>(graph.VertexCount); return(v => { string id; if (!ids.TryGetValue(v, out id)) { ids[v] = id = ids.Count.ToString(); } return id; }); }
/// <summary> /// Gets the vertex identity. /// </summary> /// <remarks> /// Returns more efficient methods for primitive types, /// otherwise builds a dictionary /// </remarks> /// <typeparam name="TVertex">The type of the vertex.</typeparam> /// <param name="graph">The graph.</param> /// <returns></returns> public static VertexIdentity <TVertex> GetVertexIdentity <TVertex>( this IVertexSet <TVertex> graph) { Contract.Requires(graph != null); // simpler identity for primitive types if (typeof(TVertex) == typeof(string) || typeof(TVertex) == typeof(bool) || typeof(TVertex) == typeof(byte) || typeof(TVertex) == typeof(char) || typeof(TVertex) == typeof(decimal) || typeof(TVertex) == typeof(double) || typeof(TVertex) == typeof(short) || typeof(TVertex) == typeof(int) || typeof(TVertex) == typeof(long) || typeof(TVertex) == typeof(sbyte) || typeof(TVertex) == typeof(float) || typeof(TVertex) == typeof(ushort) || typeof(TVertex) == typeof(uint) || typeof(TVertex) == typeof(ulong)) { return((v) => v.ToString()); } // create dictionary var ids = new Dictionary <TVertex, string>(graph.VertexCount); return(v => { string id; if (!ids.TryGetValue(v, out id)) { ids[v] = id = ids.Count.ToString(); } return id; }); }
private static Size EvaluateCanvasSize( [NotNull] IVertexSet <object> compoundGraph, [NotNull] ILayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > > algorithm, [NotNull] IReadOnlyDictionary <object, Size> verticesSizes) { var topLeft = new Point(double.PositiveInfinity, double.PositiveInfinity); var bottomRight = new Point(double.NegativeInfinity, double.NegativeInfinity); foreach (object v in compoundGraph.Vertices) { Point pos = algorithm.VerticesPositions[v]; Size size = verticesSizes[v]; topLeft.X = Math.Min(topLeft.X, pos.X - size.Width / 2.0); topLeft.Y = Math.Min(topLeft.Y, pos.Y - size.Height / 2.0); bottomRight.X = Math.Max(bottomRight.X, pos.X + size.Width / 2.0); bottomRight.Y = Math.Max(bottomRight.Y, pos.Y + size.Height / 2.0); } Vector sizeVector = bottomRight - topLeft; return(new Size(sizeVector.X, sizeVector.Y)); }
public static void AssertNoVertex <TVertex>(IVertexSet <TVertex> graph) { Assert.IsTrue(graph.IsVerticesEmpty); Assert.AreEqual(0, graph.VertexCount); CollectionAssert.IsEmpty(graph.Vertices); }
private void Check(IVertexSet<IGeometry> graph, IDictionary<IEdge<IGeometry>, double> consts, VertexPredecessorRecorderObserver<IGeometry, IEdge<IGeometry>> predecessorObserver) { foreach (IGeometry v in graph.Vertices) { double distance = 0; IGeometry vertex = v; IEdge<IGeometry> predecessor; while (predecessorObserver.VertexPredecessors.TryGetValue(vertex, out predecessor)) { distance += consts[predecessor]; vertex = predecessor.Source; } Console.WriteLine("A -> {0}: {1}", v, distance); } }
public static bool InVertexSet <TVertex>( [NotNull] IVertexSet <TVertex> graph, [NotNull] TVertex vertex) { return(graph.ContainsVertex(vertex)); }
public static bool InVertexSet <TVertex>( IVertexSet <TVertex> graph, TVertex vertex) { return(graph.ContainsVertex(vertex)); }