public void Prim12240() { var g = new UndirectedGraph <int, Edge <int> >(); // (1,2), (3,2),(3,4),(1,4) g.AddVerticesAndEdge(new Edge <int>(1, 2)); g.AddVerticesAndEdge(new Edge <int>(3, 2)); g.AddVerticesAndEdge(new Edge <int>(3, 4)); g.AddVerticesAndEdge(new Edge <int>(1, 4)); var cost = CompareRoot(g); Assert.AreEqual(9, cost); }
public void Clear() { int verticesRemoved = 0; int edgesRemoved = 0; var graph = new UndirectedGraph <int, Edge <int> >(); // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local graph.VertexRemoved += v => { Assert.IsNotNull(v); // ReSharper disable once AccessToModifiedClosure ++verticesRemoved; }; // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local graph.EdgeRemoved += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesRemoved; }; AssertEmptyGraph(graph); graph.Clear(); AssertEmptyGraph(graph); CheckCounters(0, 0); graph.AddVerticesAndEdge(new Edge <int>(1, 2)); graph.AddVerticesAndEdge(new Edge <int>(2, 3)); graph.AddVerticesAndEdge(new Edge <int>(3, 1)); graph.Clear(); AssertEmptyGraph(graph); CheckCounters(3, 3); #region Local function void CheckCounters(int expectedVerticesRemoved, int expectedEdgesRemoved) { Assert.AreEqual(expectedVerticesRemoved, verticesRemoved); Assert.AreEqual(expectedEdgesRemoved, edgesRemoved); verticesRemoved = 0; edgesRemoved = 0; } #endregion }
// Cria objeto QuickGraph private void CriaObjQuickGraph() { //QuickGraph _quickGraph = new UndirectedGraph <string, Edge <string> >(); // map de custos _edgeCost = new Dictionary <Edge <string>, double>(); // para todos os elementos da matriz de incidencia foreach (KeyValuePair <string, List <string> > kvp in _matrizIncidencia) { // aresta string sAresta1 = kvp.Key; // vertices string vertice1 = (kvp.Value)[0]; string vertice2 = (kvp.Value)[1]; //cria aresta Edge <string> aresta = new Edge <string>(vertice1, vertice2); // Adiciona vertices e arestas _quickGraph.AddVerticesAndEdge(aresta); // Custo de todas as arestas eh 1 _edgeCost.Add(aresta, 1); } }
public void clearTest() { var graph = new UndirectedGraph <int, IEdge <int> >(); graph.AddVerticesAndEdge(new EquatableEdge <int>(1, 2)); graph.AddVerticesAndEdge(new EquatableEdge <int>(2, 3)); Assert.AreEqual(graph.EdgeCount, 2); Assert.AreEqual(graph.VertexCount, 3); Assert.IsFalse(graph.IsEdgesEmpty); Assert.IsFalse(graph.IsVerticesEmpty); graph.Clear(); Assert.AreEqual(graph.EdgeCount, 0); Assert.AreEqual(graph.VertexCount, 0); Assert.IsTrue(graph.IsEdgesEmpty); Assert.IsTrue(graph.IsVerticesEmpty); }
/// <summary> /// Reads the content of the file whose name is supplied and constructs the nodes and edges for /// the given <paramref name="newGRaphInstance"/>. It is assumed the file uploaded contains edges /// (pairs of nodes connecting with each other). /// </summary> /// <param name="filename">The uploaded filename</param> /// <param name="newGraphInstance"></param> /// <returns>A string containing feedback of the processing</returns> private static string LoadGraph <T>(string filename, UndirectedGraph <T> newGraphInstance) { var lines = File.ReadAllLines(filename); Stopwatch sw = Stopwatch.StartNew(); //Parallelizing this actually made it take longer to process my datasets string[] tmp; T temp_node; T temp_node2; foreach (var line in lines) { if (line.StartsWith("#")) { continue; } tmp = line.Split(new string[] { " ", "\t" }, StringSplitOptions.None); temp_node = (T)Convert.ChangeType(tmp[0], typeof(T)); temp_node2 = (T)Convert.ChangeType(tmp[1], typeof(T)); newGraphInstance.AddVerticesAndEdge(new Edge <T>(temp_node, temp_node2)); } sw.Stop(); filename = new FileInfo(filename).Name; var nodeCount = newGraphInstance.VertexCount; var edgeCount = newGraphInstance.EdgeCount; var inv = (nodeCount * nodeCount) / edgeCount; var sparse = inv > 64; var invDeg = string.Format("{0} ({1} Graph)", inv, inv > 64 ? "Sparse" : "Dense"); return($"\tFile loaded: {filename}\n\nNumber of lines in file:\t{edgeCount}\nNumber of nodes:\t\t{nodeCount}\nInv Degree:\t{invDeg}\nTime Taken to Process:\t{sw.ElapsedMilliseconds:N2} ms"); }
private void RefreshAdjacencyList() { _adjacencyGraph.Clear(); var finishedVertices = new HashSet <Piece>(); foreach (KeyValuePair <Piece, Hex> kvp in _playedPieces) { foreach (Hex directionHex in Neighborhood.neighborDirections) { // don't do the center if (directionHex.Equals(new Hex(0, 0))) { continue; } Hex adjacentHex = kvp.Value + directionHex; Piece adjacentPiece; if (TryGetPieceAtHex(adjacentHex, out adjacentPiece)) { if (!finishedVertices.Contains(adjacentPiece)) { _adjacencyGraph.AddVerticesAndEdge(new UndirectedEdge <Piece>(kvp.Key, adjacentPiece)); } } } finishedVertices.Add(kvp.Key); } }
public void generateUndirectedGraph(int FedID, string networkName) { string sqlStmt = "SELECT a.node_id, b.elementid, b.elementtype, b.name, b.body_major_axis_centroid from " + DBOperation.formatTabName(networkName) + "_node$ a, " + "bimrl_element_" + FedID.ToString("X4") + " b where a.node_name = b.elementid"; OracleCommand command = new OracleCommand(sqlStmt, DBOperation.DBConn); try { // Populate Dict with node information (with basic information from BIMRL_ELEMENT) OracleDataReader reader = command.ExecuteReader(); while (reader.Read()) { int nodeID = reader.GetInt32(0); string elemID = reader.GetString(1); string elemType = reader.GetString(2); string name = string.Empty; if (!reader.IsDBNull(3)) { name = reader.GetString(3); } Point3D centroid = null; if (!reader.IsDBNull(4)) { SdoGeometry sdogeom = reader.GetValue(4) as SdoGeometry; centroid = new Point3D(sdogeom.SdoPoint.XD.Value, sdogeom.SdoPoint.YD.Value, sdogeom.SdoPoint.ZD.Value); } NodeDict.Add(nodeID, new Tuple <string, string, string, Point3D>(elemID, elemType, name, centroid)); ElemIDToNodeIDDict.Add(elemID, nodeID); } reader.Dispose(); // generate the graph sqlStmt = "Select link_id, start_node_id, end_node_id from " + DBOperation.formatTabName(networkName) + "_link$ where active='Y'"; command.CommandText = sqlStmt; reader = command.ExecuteReader(); while (reader.Read()) { int linkID = reader.GetInt32(0); int startNode = reader.GetInt32(1); int endNode = reader.GetInt32(2); var edge = new TaggedEdge <int, int>(startNode, endNode, linkID); graph.AddVerticesAndEdge(edge); } reader.Dispose(); command.Dispose(); } catch (OracleException e) { string excStr = "%%Error - " + e.Message + "\n\t" + sqlStmt; refBimrlCommon.StackPushError(excStr); command.Dispose(); } catch (SystemException e) { string excStr = "%%Error - " + e.Message + "\n\t" + sqlStmt; refBimrlCommon.StackPushError(excStr); throw; } }
private UndirectedGraph<int, TaggedUndirectedEdge<int, double>> createGraph(List<TaggedUndirectedEdge<int, double>> edges) { var g = new UndirectedGraph<int, TaggedUndirectedEdge<int, double>>(true); foreach (TaggedUndirectedEdge<int, double> edge in edges) { g.AddVerticesAndEdge(edge); } return g; }
private UndirectedGraph<int, UndirectedEdge<int>> constructGraph(Tuple<int, int>[] vertices) { var g = new UndirectedGraph<int, UndirectedEdge<int>>(); foreach (var pair in vertices) { g.AddVerticesAndEdge(new UndirectedEdge<int>(pair.Item1, pair.Item2)); } return g; }
private UndirectedGraph <int, UndirectedEdge <int> > constructGraph(Tuple <int, int>[] vertices) { var g = new UndirectedGraph <int, UndirectedEdge <int> >(); foreach (var pair in vertices) { g.AddVerticesAndEdge(new UndirectedEdge <int>(pair.Item1, pair.Item2)); } return(g); }
private UndirectedGraph <int, TaggedUndirectedEdge <int, double> > createGraph(List <TaggedUndirectedEdge <int, double> > edges) { var g = new UndirectedGraph <int, TaggedUndirectedEdge <int, double> >(true); foreach (TaggedUndirectedEdge <int, double> edge in edges) { g.AddVerticesAndEdge(edge); } return(g); }
public void ContainsEdge_UndirectedEdge() { var graph = new UndirectedGraph <int, IEdge <int> >(); var e12 = new EquatableUndirectedEdge <int>(1, 2); var f12 = new EquatableUndirectedEdge <int>(1, 2); graph.AddVerticesAndEdge(e12); ContainsEdgeAssertions(graph, e12, f12, null, null); }
public static (List <HashSet <int> >, UndirectedGraph <int, IEdge <int> >, Dictionary <int, (int, int)>) GetBFSTree(UndirectedGraph <int, IEdge <int> > graph, int root) { UndirectedGraph <int, IEdge <int> > BFSTree = new UndirectedGraph <int, IEdge <int> >(false); List <HashSet <int> > levels = new List <HashSet <int> >(); Dictionary <int, (int, int)> dict = new Dictionary <int, (int, int)>(); HashSet <int> enqueued = new HashSet <int>(); int level = 0; int intNumberOnLevel = 0; levels.Add(new HashSet <int>()); Queue <int> queue = new Queue <int>(); int nextLevelMark = -1; queue.Enqueue(root); enqueued.Add(root); queue.Enqueue(nextLevelMark); while (queue.Count > 0) { int v = queue.Dequeue(); //Moving to next level if (v == nextLevelMark) { level++; if (queue.Count == 0) { break; } queue.Enqueue(nextLevelMark); levels.Add(new HashSet <int>()); intNumberOnLevel = 0; continue; } levels[level].Add(v); dict.Add(v, (level, intNumberOnLevel)); intNumberOnLevel++; //Add all v neighbours to queue foreach (IEdge <int> e in graph.AdjacentEdges(v)) { if (!enqueued.Contains(e.GetOtherVertex(v))) { queue.Enqueue(e.GetOtherVertex(v)); enqueued.Add(e.GetOtherVertex(v)); BFSTree.AddVerticesAndEdge(new Edge <int>(v, e.GetOtherVertex(v))); } } } levels.Add(new HashSet <int>()); return(levels, BFSTree, dict); }
private static UndirectedGraph <int, UndirectedEdge <int> > ConstructGraph([NotNull] IEnumerable <Vertices> vertices) { var graph = new UndirectedGraph <int, UndirectedEdge <int> >(); foreach (Vertices pair in vertices) { graph.AddVerticesAndEdge(new UndirectedEdge <int>(pair.Source, pair.Target)); } return(graph); }
/// <summary> /// Add a room connection to the map. New nodes will be created for previously unseen rooms /// </summary> /// <param name="startRoom"></param> /// <param name="endRoom"></param> public void AddRoomConnection(int startRoom, int endRoom) { try { TaggedEdge <int, string> possibleEdge = null; baseGraph.TryGetEdge(startRoom, endRoom, out possibleEdge); if (possibleEdge == null) { baseGraph.AddVerticesAndEdge(new TaggedEdge <int, string>(startRoom, endRoom, "")); } } catch (KeyNotFoundException) { //Vertex not in graph, OK to add baseGraph.AddVerticesAndEdge(new TaggedEdge <int, string>(startRoom, endRoom, "")); } //Other exceptions passed up }
public void ContainsEdgeTest2() { var u = new UndirectedGraph <int, IEdge <int> >(); var e12 = new EquatableEdge <int>(1, 2); var f12 = new EquatableEdge <int>(1, 2); var e21 = new EquatableEdge <int>(2, 1); var f21 = new EquatableEdge <int>(2, 1); u.AddVerticesAndEdge(e12); ContainsEdgeAssertions(u, e12, f12, e21, f21); }
private static UndirectedGraph <int, TaggedUndirectedEdge <int, double> > CreateGraph( [NotNull, ItemNotNull] IEnumerable <TaggedUndirectedEdge <int, double> > edges) { var graph = new UndirectedGraph <int, TaggedUndirectedEdge <int, double> >(true); foreach (TaggedUndirectedEdge <int, double> edge in edges) { graph.AddVerticesAndEdge(edge); } return(graph); }
public static UndirectedGraph <int, UndirectedEdge <int> > CreateUndirectedGraph( IEnumerable <Vertices> vertices) { var graph = new UndirectedGraph <int, UndirectedEdge <int> >(); foreach (Vertices pair in vertices) { graph.AddVerticesAndEdge(new UndirectedEdge <int>(pair.Source, pair.Target)); } return(graph); }
public void ContainsEdge_DirectedEdge() { var graph = new UndirectedGraph <int, IEdge <int> >(); var e12 = new EquatableEdge <int>(1, 2); var f12 = new EquatableEdge <int>(1, 2); var e21 = new EquatableEdge <int>(2, 1); var f21 = new EquatableEdge <int>(2, 1); graph.AddVerticesAndEdge(e12); ContainsEdgeAssertions(graph, e12, f12, e21, f21); }
private static IList <Edge> ComputeShortestPath(Edge branch, IEnumerable <Edge> delaunyEdges, Matrix volumeIndexToNormalizedVolumeCoordinates) { var graph = new UndirectedGraph <Vector3, Edge <Vector3> >(); foreach (var delaunyEdge in delaunyEdges) { graph.AddVerticesAndEdge(new Edge <Vector3>(delaunyEdge.P1, delaunyEdge.P2)); } var dijkstraShortestPathAlgorithm = new UndirectedDijkstraShortestPathAlgorithm <Vector3, Edge <Vector3> >(graph, edge => CalculateEdgeWeights(edge, volumeIndexToNormalizedVolumeCoordinates)); var visitor = new UndirectedVertexPredecessorRecorderObserver <Vector3, Edge <Vector3> >(); using (visitor.Attach(dijkstraShortestPathAlgorithm)) { dijkstraShortestPathAlgorithm.Compute(branch.P1); } IEnumerable <Edge <Vector3> > shortestPath; visitor.TryGetPath(branch.P2, out shortestPath); var edgeList = (from edge in shortestPath select new Edge { P1 = edge.Source, P2 = edge.Target }).ToList(); var orientedEdgeList = new List <Edge>(); var edgeListP1 = edgeList[0].P1; var edgeListP2 = edgeList[0].P2; orientedEdgeList.Add(!edgeList[0].P1.Equals(branch.P1) ? new Edge { P1 = edgeListP2, P2 = edgeListP1 } : new Edge { P1 = edgeListP1, P2 = edgeListP2 }); for (int i = 1; i < edgeList.Count; i++) { edgeListP1 = edgeList[i].P1; edgeListP2 = edgeList[i].P2; orientedEdgeList.Add(!edgeList[i].P1.Equals(orientedEdgeList[i - 1].P2) ? new Edge { P1 = edgeListP2, P2 = edgeListP1 } : new Edge { P1 = edgeListP1, P2 = edgeListP2 }); } return(orientedEdgeList); }
public void Run() { var g = new UndirectedGraph <int, TaggedUndirectedEdge <int, int> >(); var e1 = new TaggedUndirectedEdge <int, int>(1, 2, 57); var e2 = new TaggedUndirectedEdge <int, int>(1, 4, 65); var e3 = new TaggedUndirectedEdge <int, int>(2, 3, 500); var e4 = new TaggedUndirectedEdge <int, int>(2, 4, 1); var e5 = new TaggedUndirectedEdge <int, int>(3, 4, 78); var e6 = new TaggedUndirectedEdge <int, int>(3, 5, 200); g.AddVerticesAndEdge(e1); g.AddVerticesAndEdge(e2); g.AddVerticesAndEdge(e3); g.AddVerticesAndEdge(e4); g.AddVerticesAndEdge(e5); g.AddVerticesAndEdge(e6); foreach (var v in g.Edges) { Console.WriteLine(v); } Console.WriteLine("--------"); //Func<TaggedUndirectedEdge<int, int>, double> edgeWeights = (q) => //{ // g.Edges.SingleOrDefault(m => q == m).Tag; //}; var mst = g.MinimumSpanningTreePrim(e => e.Tag).ToList(); foreach (var v in mst) { Console.WriteLine(v); } }
public RandomPlanar(double density, Random random) { _density = Math.Clamp(density, 0, 1); this.random = random; Graph = new UndirectedGraph <int, IEdge <int> >(); Graph.AddVerticesAndEdge(new Edge <int>(0, 1)); _faces = new List <Face>() { new Face(random, new List <int> { 0, 1 }) }; }
public void GetVertexColor() { var graph = new UndirectedGraph <int, Edge <int> >(); graph.AddVerticesAndEdge(new Edge <int>(1, 2)); var algorithm = new UndirectedDijkstraShortestPathAlgorithm <int, Edge <int> >(graph, edge => 1.0); algorithm.Compute(1); Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(1)); Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(2)); }
public static UndirectedGraph <TVertex, TEdge> CreateUndirectedGraph <TVertex, TEdge>( [NotNull, ItemNotNull] IEnumerable <TEdge> edges) where TEdge : IEdge <TVertex>, ITagged <double> { var graph = new UndirectedGraph <TVertex, TEdge>(true); foreach (TEdge edge in edges) { graph.AddVerticesAndEdge(edge); } return(graph); }
public void removeIsolatedVertices() { var graph = new UndirectedGraph <int, IEdge <int> >(); graph.AddVertex(1); var edge = new EquatableEdge <int>(2, 3); graph.AddVerticesAndEdge(edge); graph.RemoveVertexIf(graph.IsAdjacentEdgesEmpty); Assert.IsTrue(graph.ContainsVertex(2)); Assert.IsTrue(graph.ContainsEdge(edge)); Assert.IsTrue(graph.ContainsEdge(2, 3)); Assert.IsTrue(graph.ContainsEdge(3, 2)); Assert.IsFalse(graph.ContainsVertex(1)); }
private static UndirectedGraph <int, Edge <int> > GetGraphFromEdges(IEnumerable <Edge <int> > edges) { //var edgeComparer = new EdgeComparer(); var graphFromEdges = new UndirectedGraph <int, Edge <int> >(); foreach (var edge in edges) { graphFromEdges.AddVerticesAndEdge(edge); } if (graphFromEdges.EdgeCount != edges.Count()) { throw new ArgumentException("AugmentingPathGraph creation error"); } return(graphFromEdges); }
public void toBidirectionalGraphTest() { var graph = new UndirectedGraph <int, IEdge <int> >(); graph.AddVertex(1); var edge = new EquatableEdge <int>(2, 3); graph.AddVerticesAndEdge(edge); var bidirectionalGraph = graph.ToBidirectionalGraph(); Assert.IsTrue(bidirectionalGraph.ContainsVertex(1)); Assert.IsTrue(bidirectionalGraph.ContainsVertex(2)); Assert.IsTrue(bidirectionalGraph.ContainsVertex(3)); Assert.IsTrue(bidirectionalGraph.ContainsEdge(2, 3)); Assert.IsFalse(bidirectionalGraph.ContainsEdge(3, 2)); }
public void UndirectedEdgesMayBeFoundInEitherOrientation() { var mapNoCycles = new UndirectedGraph <int, TaggedEdge <int, string> >(); mapNoCycles.AddVerticesAndEdge(new TaggedEdge <int, string>(1, 2, "")); TaggedEdge <int, string> possibleEdge = null; mapNoCycles.TryGetEdge(2, 1, out possibleEdge); Assert.IsNotNull(possibleEdge); TaggedEdge <int, string> possibleEdge2 = null; mapNoCycles.TryGetEdge(1, 2, out possibleEdge2); Assert.IsNotNull(possibleEdge2); }
public void GetVertexColor() { var graph = new UndirectedGraph <int, Edge <int> >(); graph.AddVerticesAndEdge(new Edge <int>(1, 2)); var algorithm = new UndirectedBreadthFirstSearchAlgorithm <int, Edge <int> >(graph); // Algorithm not run // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Assert.Throws <VertexNotFoundException>(() => algorithm.GetVertexColor(1)); algorithm.Compute(1); Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(1)); Assert.AreEqual(GraphColor.Black, algorithm.GetVertexColor(2)); }
public void RemoveEdges_Throws() { int verticesRemoved = 0; int edgesRemoved = 0; var graph = new UndirectedGraph <int, Edge <int> >(); // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local graph.VertexRemoved += v => { Assert.IsNotNull(v); ++verticesRemoved; }; // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local graph.EdgeRemoved += e => { Assert.IsNotNull(e); ++edgesRemoved; }; var edge = new Edge <int>(1, 2); graph.AddVerticesAndEdge(edge); // ReSharper disable once AssignNullToNotNullAttribute Assert.Throws <ArgumentNullException>(() => graph.RemoveEdges(null)); AssertHasEdges(graph, new[] { edge }); CheckCounters(); Assert.Throws <ArgumentNullException>(() => graph.RemoveEdges(new[] { edge, null })); Assert.AreEqual(0, edgesRemoved); AssertHasEdges(graph, new[] { edge }); CheckCounters(); #region Local function void CheckCounters() { Assert.AreEqual(0, verticesRemoved); Assert.AreEqual(0, edgesRemoved); } #endregion }
/// <summary> /// Reads the content of the file whose name is supplied and constructs the nodes and edges for /// the given <paramref name="newGRaphInstance"/>. It is assumed the file uploaded contains edges /// (pairs of nodes connecting with each other). /// </summary> /// <param name="filename">The uploaded filename</param> /// <returns>A string containing feedback of the processing</returns> public static UndirectedGraph <int> LoadGraph(string[] lines) { //since system io is not used, lines is given as an array of the lines in the txt file //just like what readalllines does //do note that the first line in the file was not read //var lines = File.ReadAllLines(filename); UndirectedGraph <int> newGraphInstance; newGraphInstance = new UndirectedGraph <int>(); //not needed since demo doesnt use q graphs //if (isQueryGraph) //{ // //newGraphInstance = new QueryGraph(Path.GetFileNameWithoutExtension(filename)) // //{ // //}; //} //else //{ // newGraphInstance = new UndirectedGraph<int>(); //} //Parallelizing this actually made it take longer to process my datasets string[] tmp; foreach (var line in lines) { if (line.StartsWith("#")) { continue; } tmp = line.Split(new string[] { " ", "\t" }, StringSplitOptions.RemoveEmptyEntries); if (tmp.Length < 2) { continue; } //newGraphInstance.AddVerticesAndEdge(new Edge<int>(tmp[0], tmp[1])); newGraphInstance.AddVerticesAndEdge(int.Parse(tmp[0]), int.Parse(tmp[1])); } return(newGraphInstance); }
public HashSet<HashSet<int>> GetMaxDomaticPartition(int[] vertices, Tuple<int, int>[] edges) { var graph = new UndirectedGraph<int, Edge<int>>(); graph.AddVertexRange(vertices); foreach (var edge in edges) { graph.AddVerticesAndEdge(new Edge<int>(edge.Item1, edge.Item2)); } var algo = new DomaticPartition<int, Edge<int>>(graph); IEnumerable<IEnumerable<int>> partition = algo.GetMaxSizePartition(); var hashsetPartition = new HashSet<HashSet<int>>(); foreach (var set in partition) { var curSet = new HashSet<int>(set); hashsetPartition.Add(curSet); } return hashsetPartition; }
private DegeneracyResult AnalyzeDegeneracy(string file) { var graph = new UndirectedGraph <int, Edge <int> >(); this.rowByRow(file, row => { var split = row.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries); int v; int u; if (split.Length != 2 || !int.TryParse(split[0], out v) || !int.TryParse(split[1], out u)) { return; } graph.AddVerticesAndEdge(new Edge <int>(u, v)); }); return(graph.CoreDecomposition()); }
public void ContainsEdgeTest1() { var u = new UndirectedGraph<int, IEdge<int>>(); var e12 = new SEquatableUndirectedEdge<int>(1, 2); var f12 = new SEquatableUndirectedEdge<int>(1, 2); bool exceptionOccurred = false; try { new SEquatableUndirectedEdge<int>(2, 1); } catch (ArgumentException e) { exceptionOccurred = true; } Assert.IsTrue(exceptionOccurred); u.AddVerticesAndEdge(e12); ContainsEdgeAssertions(u, e12, f12, null, null); }
public void ContainsEdgeTest2() { var u = new UndirectedGraph<int, IEdge<int>>(); var e12 = new EquatableEdge<int>(1, 2); var f12 = new EquatableEdge<int>(1, 2); var e21 = new EquatableEdge<int>(2, 1); var f21 = new EquatableEdge<int>(2, 1); u.AddVerticesAndEdge(e12); ContainsEdgeAssertions(u, e12, f12, e21, f21); }
public void UndirectedEdgesMayBeFoundInEitherOrientation() { var mapNoCycles = new UndirectedGraph<int, TaggedEdge<int, string>>(); mapNoCycles.AddVerticesAndEdge(new TaggedEdge<int, string>(1, 2, "")); TaggedEdge<int, string> possibleEdge = null; mapNoCycles.TryGetEdge(2, 1, out possibleEdge); Assert.IsNotNull(possibleEdge); TaggedEdge<int, string> possibleEdge2 = null; mapNoCycles.TryGetEdge(1, 2, out possibleEdge2); Assert.IsNotNull(possibleEdge2); }