/// <summary> /// Adds an undirected weighted edge to the graph /// </summary> /// <param name="st"></param> /// <param name="end"></param> /// <param name="weight">weight of the edge</param> public void AddEdge(int st, int end, int weight) { if (!Edges.ContainsKey(st)) { Edges[st] = new List <Edge>() { new Edge(st, end, weight) }; } else { Edges[st].Add(new Edge(st, end, weight)); } if (!Edges.ContainsKey(end)) { Edges[end] = new List <Edge>() { new Edge(end, st, weight) }; } else { Edges[end].Add(new Edge(end, st, weight)); } TotalNumOfEdges += 2; }
public void AddEdge(string v1Label, string v2Label) { // Create node map if (!VertexLabelMap.ContainsKey(v1Label)) { VertexLabelMap.Add(v1Label, VertexLabelMap.Count); VertexIndexMap.Add(VertexIndexMap.Count, v1Label); } // Create node map if (!VertexLabelMap.ContainsKey(v2Label)) { VertexLabelMap.Add(v2Label, VertexLabelMap.Count); VertexIndexMap.Add(VertexIndexMap.Count, v2Label); } // Add edge and vertices if (!Edges.ContainsKey(VertexLabelMap[v1Label])) { Edges.Add(VertexLabelMap[v1Label], new HashSet <int>()); GraphWeight += Vertices[VertexLabelMap[v1Label]]; } if (!Edges.ContainsKey(VertexLabelMap[v2Label])) { Edges.Add(VertexLabelMap[v2Label], new HashSet <int> ()); GraphWeight += Vertices[VertexLabelMap[v2Label]]; } Edges[VertexLabelMap[v2Label]].Add(VertexLabelMap[v1Label]); Edges[VertexLabelMap[v1Label]].Add(VertexLabelMap[v2Label]); }
public void AddEdge(T1 from, T1 to, T2 w) { if (!Nodes.ContainsKey(from) || !Nodes.ContainsKey(to) || w is null) { throw new Exception("Node don't exist"); } var fromNode = Nodes[from]; var toNode = Nodes[to]; if (!Edges.ContainsKey(from)) { Edges.Add(from, new LinkedList <Edge>()); } if (!Edges.ContainsKey(to)) { Edges.Add(to, new LinkedList <Edge>()); } Edges[from].AddLast(new Edge { From = fromNode, To = toNode, Weigth = w }); Edges[to].AddLast(new Edge { From = toNode, To = fromNode, Weigth = w }); }
public IEdge AddEdge(IEdge edge) { if (edge == null) { throw new ArgumentNullException(nameof(edge)); } if (!Equals(edge.Parent) && !SubGraphs.ContainsKey(edge.Parent)) { throw new ArgumentException(FormattableString.Invariant($"Parent of Edge {edge} not within Graph!")); } if ((edge.SourceNode == null) || !Nodes.ContainsKey(edge.SourceNode)) { throw new ArgumentException( FormattableString.Invariant($"SourceNode {edge.SourceNode} not within Graph!")); } if ((edge.EndNode == null) || !Nodes.ContainsKey(edge.EndNode)) { throw new ArgumentException(FormattableString.Invariant($"EndNode {edge.EndNode} not within Graph!")); } if (!Edges.ContainsKey(edge)) { Edges[edge] = edge; } var addedEdge = Edges[edge]; addedEdge.SetAttributes(edge.GetAttributes()); return(addedEdge); }
public void AddEdge(IEdgeUiElement e) { if (!Edges.ContainsKey(e.Id)) { Edges.Add(e.Id, e); } InvalidateVisual(); }
public void RemoveEdge(IEdgeUiElement e) { if (Edges.ContainsKey(e.Id)) { Edges.Remove(e.Id); } InvalidateVisual(); }
public IEdgeUiElement FindEdge(IVertexElement v) { var idEdge = HashCode.GetHashCode(Id, v.Id); if (Edges.ContainsKey(idEdge)) { return(Edges[idEdge]); } return(null); }
public bool HasEdge(INode firstNode, INode secondNode) { if (IsDirected) { return(Edges.ContainsKey(firstNode) && Edges[firstNode].Any(edge => edge.SecondNode == secondNode)); } return(Edges.ContainsKey(secondNode) && Edges[secondNode].Any(edge => edge.SecondNode == firstNode)); }
public Dictionary <Node, Node> FindPath(Node s) // s là đỉnh gốc { Dictionary <Node, double> d = new Dictionary <Node, double>(V); // nhãn của nút Dictionary <Node, double> L = new Dictionary <Node, double>(V); // nhãn của nút theo prim-dijkstra Dictionary <Node, bool> visited = new Dictionary <Node, bool>(V); Dictionary <Node, Node> p = new Dictionary <Node, Node>(V); // p[u] = v tức là u là con của v for (int i = 0; i < Nodes.Count; i++) { d[Nodes[i]] = INF; L[Nodes[i]] = INF; visited[Nodes[i]] = false; //p[Nodes[i]] = s; } d[s] = 0; L[s] = 0; int count = 1; double lMin; Node u = s; while (count < V) { lMin = INF; //Tìm node có nhãn min for (int i = 0; i < V; i++) { if (!visited[Nodes[i]] && L[Nodes[i]] < lMin) { lMin = L[Nodes[i]]; u = Nodes[i]; } } //Xét node u visited[u] = true; for (int i = 0; i < V; i++) { Tuple <Node, Node> t = Tuple.Create(u, Nodes[i]); if (!visited[Nodes[i]] && Edges.ContainsKey(t) && Alpha * d[u] + Edges[t] < L[Nodes[i]]) { d[Nodes[i]] = d[u] + Edges[t]; L[Nodes[i]] = Alpha * d[u] + Edges[t]; p[Nodes[i]] = u; } } count++; } return(p); }
public void Add(Edge edge) { if (edge != null) { edge.SetFace(this); var adjusted = GetAdjustedStart(edge); if (adjusted != null && !Edges.ContainsKey(adjusted)) { Edges.Add(GetAdjustedStart(edge), edge); FindHole(); } } }
private static bool IsWired(GraphNode node1, GraphNode node2) { if (Edges.ContainsKey(node1)) { foreach (GraphEdge edge in Edges[node1]) { if (edge.NodeFirst == node2 || edge.NodeSecond == node2) { return(true); } } } return(false); }
public Edge Add(Edge edge) { if (Edges.ContainsKey(edge)) { Edge existingVertex; Edges.TryGetValue(edge, out existingVertex); return(existingVertex); } else { Edges.Add(edge, edge); return(edge); } }
/// <summary> /// /// </summary> /// <param name="v"></param> /// <returns></returns> public IEdge <KEY> this[INode <KEY> v] { get { EdgeKey <KEY> key = new EdgeKey <KEY>(Key, v.Key); if (Edges.ContainsKey(key)) { return(Edges[key]); } else { return(null); } } }
public void AddNewNeighbour(int source, int destination, int weight) { destination--; if (weight > 0) { if (!Edges.ContainsKey(source)) { Edges.Add(source, new List <Edge>()); } Edges[source].Add(new Edge(source, destination, weight)); } EdgesNo = Edges.Count; }
public void AddEdge(string edge, int tileId, int edgeNumber, bool match) { if (Edges.ContainsKey(edge)) { // exists add this tile if not there already if (!Edges[edge].Any(t => t.Item1 == tileId && t.Item2 == edgeNumber)) { Edges[edge].Add(Tuple.Create(tileId, edgeNumber, match)); } } else { List <Tuple <int, int, bool> > list = new List <Tuple <int, int, bool> >(); list.Add(Tuple.Create(tileId, edgeNumber, match)); Edges.Add(edge, list); } }
public void RemoveById(int id) { if (Verticies.ContainsKey(id)) { Verticies.Remove(id); if (VertexOfEdgesById.ContainsKey(id)) { VertexOfEdgesById.Remove(id); } } if (Edges.ContainsKey(id)) { var e = Edges[id]; VertexOfEdgesById.Remove(e.FromId); VertexOfEdgesById.Remove(e.ToId); Edges.Remove(id); } }
public IWeightedDirectedPath <TVertex, TEdge> Path(TVertex destination) { if (Equals(Origin, destination)) { return(new WeightedDirectedPath <TVertex, TEdge>(Graph, Origin)); } if (!Edges.ContainsKey(destination) || Equals(Edges[destination].Item1, default(TEdge))) { return(null); } var edges = new LinkedList <TEdge>(); var vertices = new LinkedList <TVertex>(); var current = destination; var weight = default(TEdge); while (Edges.ContainsKey(current)) { var inedge = Edges[current].Item2; if (inedge == null) { break; } edges.AddFirst(inedge); vertices.AddFirst(current); bool Predicate(IWeightedEndpoint <TVertex, TEdge> endpoint) { return(Equals(endpoint.Edge, inedge)); } current = Graph.PredecessorEndpoints(current).Single(Predicate).Vertex; weight = Adder.Add(weight, inedge); } vertices.AddFirst(current); return(new WeightedDirectedPath <TVertex, TEdge>(Graph, Origin, destination, vertices, edges, weight)); }
protected void AddEdgeForNode(INode node, IEdge edge) { if (Edges.ContainsKey(node)) { if (Edges[node].Contains(edge)) { throw new ArgumentException( string.Format("The edge {0}-{1} already exists for node {2}", edge.FirstNode.ID, edge.SecondNode.ID, node.ID)); } Edges[node].Add(edge); } else { IList <IEdge> edges = new List <IEdge>(); edges.Add(edge); Edges.Add(node, edges); } }
public static void RemoveNode(GraphNode node) { Canvas canvas = node.Parent as Canvas; if (canvas != null) { if (Edges.ContainsKey(node)) { foreach (GraphEdge edge in Edges[node]) { if (node == edge.NodeFirst) { Edges[edge.NodeSecond].Remove(edge); } else { Edges[edge.NodeFirst].Remove(edge); } canvas.Children.Remove(edge.EdgeLine); canvas.Children.Remove(edge.WeightLabel); } Edges.Remove(node); } canvas.Children.Remove(node); Nodes.Remove(node); Adjency.Remove(node); if (node.Index == LastIndex) { LastIndex--; } } }
internal Edge FindEdgeByChar(char c) { return(!Edges.ContainsKey(c) ? null : Edges[c]); }
public bool HasEdgesForNode(INode node) { return(Edges.ContainsKey(node)); }
public void AfterRun(IPexPathComponent host, object data) { MessageBox.Show("AfterRun"); // Getting the executions nodes in the current path var nodesInPath = host.PathServices.CurrentExecutionNodeProvider.ReversedNodes.Reverse().ToArray(); // Getting the sequence id of the current run var runId = host.ExplorationServices.Driver.Runs; // Iterating over the nodes in the path foreach (var node in nodesInPath) { var vertex = new CFGNode(node.UniqueIndex, false); // Adding the method name this early in order to color edges string methodName = null; int offset = 0; if (node.CodeLocation.Method == null) { if (node.InCodeBranch.Method != null) { methodName = node.InCodeBranch.Method.FullName; } } else { methodName = node.CodeLocation.Method.FullName; offset = node.CodeLocation.Offset; } // Setting the method name vertex.MethodName = methodName; // Setting the offset vertex.ILOffset = (uint)offset; var nodeIndex = nodesInPath.ToList().IndexOf(node); if (nodeIndex > 0) { var prevNode = nodesInPath [nodeIndex - 1]; // If there is no edge between the previous and the current node if (!(Edges.ContainsKey(prevNode.UniqueIndex) && Edges [prevNode.UniqueIndex].ContainsKey(node.UniqueIndex))) { var prevVertex = Vertices [prevNode.UniqueIndex]; var edge = new CFGEdge(new Random().Next(), prevVertex, vertex); Dictionary <int, CFGEdge> outEdges = null; if (Edges.TryGetValue(prevNode.UniqueIndex, out outEdges)) { outEdges.Add(node.UniqueIndex, edge); } else { Edges.Add(prevNode.UniqueIndex, new Dictionary <int, CFGEdge>()); Edges [prevNode.UniqueIndex].Add(node.UniqueIndex, edge); } // Edge coloring based on unit border detection if (UnitNamespace != null) { // Checking if pointing into the unit from outside if (!(prevVertex.MethodName.StartsWith(UnitNamespace + ".") || prevVertex.MethodName.Equals(UnitNamespace)) && (vertex.MethodName.StartsWith(UnitNamespace + ".") || vertex.MethodName.Equals(UnitNamespace))) { edge.Color = CFGEdge.EdgeColor.Green; } // Checking if pointing outside the unit from inside if ((prevVertex.MethodName.StartsWith(UnitNamespace + ".") || prevVertex.MethodName.Equals(UnitNamespace)) && !(vertex.MethodName.StartsWith(UnitNamespace + ".") || vertex.MethodName.Equals(UnitNamespace))) { edge.Color = CFGEdge.EdgeColor.Red; } } } } // If the node is new then it is added to the list and the metadata is filled if (!Vertices.ContainsKey(node.UniqueIndex)) { Vertices.Add(node.UniqueIndex, vertex); // Adding source code mapping vertex.SourceCodeMappingString = MapToSourceCodeLocationString(host, node); // Setting the border based on mapping existence vertex.Border = vertex.SourceCodeMappingString == null ? CFGNode.NodeBorder.Single : CFGNode.NodeBorder.Double; // Setting the color if (nodesInPath.LastOrDefault() == node) { if (!EmittedTestResult.ContainsKey(runId)) { vertex.Color = CFGNode.NodeColor.Orange; } else { if (EmittedTestResult [runId].Item1) { vertex.Color = CFGNode.NodeColor.Red; } else { vertex.Color = CFGNode.NodeColor.Green; } vertex.GenerateTestCode = EmittedTestResult [runId].Item2; } } else { vertex.Color = CFGNode.NodeColor.White; } // Setting the default shape vertex.Shape = CFGNode.NodeShape.Rectangle; // Adding path condition tasks and getting the required services TermEmitter termEmitter = new TermEmitter(host.GetService <TermManager>()); SafeStringWriter safeStringWriter = new SafeStringWriter(); IMethodBodyWriter methodBodyWriter = host.GetService <IPexTestManager>().Language.CreateBodyWriter(safeStringWriter, VisibilityContext.Private, 2000); PrettyPathConditionTasks.Add(vertex.Id, PrettyPrintPathCondition(termEmitter, methodBodyWriter, safeStringWriter, node)); // Setting the status vertex.Status = node.ExhaustedReason.ToString(); // Collecting the parent nodes for the later incremental path condition calculation if (nodeIndex > 0) { ParentNodes.Add(vertex.Id, nodesInPath [nodeIndex - 1].UniqueIndex); } } // Adding the Id of the run Vertices [node.UniqueIndex].Runs += (runId + ";"); } }
public bool ContainsEdges(int id) { return(Edges.ContainsKey(id)); }