/// <summary> /// Fills set of edges reachable from the start node, under the type constraints given, in a depth-first walk /// </summary> private static void ReachableEdges(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, Dictionary<IEdge, SetValueType> incidentEdgesSet, IGraph graph, int threadId) { foreach(IEdge edge in startNode.GetCompatibleOutgoing(incidentEdgeType)) { INode adjacentNode = edge.Target; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; incidentEdgesSet[edge] = null; if(graph.IsInternallyVisited(adjacentNode, threadId)) continue; graph.SetInternallyVisited(adjacentNode, true, threadId); ReachableEdges(adjacentNode, incidentEdgeType, adjacentNodeType, incidentEdgesSet, graph, threadId); } foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; incidentEdgesSet[edge] = null; if(graph.IsInternallyVisited(adjacentNode, threadId)) continue; graph.SetInternallyVisited(adjacentNode, true, threadId); ReachableEdges(adjacentNode, incidentEdgeType, adjacentNodeType, incidentEdgesSet, graph, threadId); } }
////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Returns count of the edges incident to the start node, under the type constraints given /// </summary> public static int CountIncident(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, int threadId) { int count = 0; foreach(IEdge edge in startNode.GetCompatibleOutgoing(incidentEdgeType)) { INode adjacentNode = edge.Target; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; ++count; } foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(adjacentNode == startNode) continue; // count reflexive edge only once ++count; } return count; }
/// <summary> /// Returns count of the edges incoming to the start node, under the type constraints given /// </summary> public static int CountIncoming(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, int threadId) { int count = 0; foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; ++count; } return count; }
public static int CountAdjacentIncoming(IGraph graph, INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, IActionExecutionEnvironment actionEnv, int threadId) { int count = 0; foreach(IEdge edge in startNode.Incoming) { ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId]; if(!edge.InstanceOf(incidentEdgeType)) continue; INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(graph.IsInternallyVisited(adjacentNode, threadId)) continue; graph.SetInternallyVisited(adjacentNode, true, threadId); ++count; } foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; graph.SetInternallyVisited(adjacentNode, false, threadId); } return count; }
/// <summary> /// Returns set of edges incoming to the start node, under the type constraints given /// </summary> public static Dictionary<IEdge, SetValueType> Incoming(INode startNode, EdgeType incomingEdgeType, NodeType sourceNodeType, int threadId) { Dictionary<IEdge, SetValueType> incomingEdgesSet = new Dictionary<IEdge, SetValueType>(); foreach(IEdge edge in startNode.GetCompatibleIncoming(incomingEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(sourceNodeType)) continue; incomingEdgesSet[edge] = null; } return incomingEdgesSet; }
private static IEnumerable<IEdge> BoundedReachableEdgesIncomingRec(INode startNode, int depth, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, Dictionary<IEdge, SetValueType> visitedEdges, Dictionary<INode, int> sourceNodesToMinDepth, IActionExecutionEnvironment actionEnv, int threadId) { if(depth <= 0) yield break; foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId]; INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(!visitedEdges.ContainsKey(edge)) { visitedEdges[edge] = null; yield return edge; } int nodeDepth; if(sourceNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth) && nodeDepth >= depth - 1) continue; sourceNodesToMinDepth[adjacentNode] = depth - 1; foreach(IEdge reachableEdge in BoundedReachableEdgesIncomingRec(adjacentNode, depth - 1, incidentEdgeType, adjacentNodeType, graph, visitedEdges, sourceNodesToMinDepth, actionEnv, threadId)) yield return reachableEdge; } }
/// <summary> /// Returns the count of the nodes adjacent to the start node via incoming edges, under the type constraints given /// </summary> public static int CountAdjacentIncoming(IGraph graph, INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, int threadId) { int count = 0; foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(graph.IsInternallyVisited(adjacentNode, threadId)) continue; graph.SetInternallyVisited(adjacentNode, true, threadId); ++count; } foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; graph.SetInternallyVisited(adjacentNode, false, threadId); } return count; }
private static IEnumerable<INode> BoundedReachableRec(INode startNode, int depth, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, Dictionary<INode, int> adjacentNodesToMinDepth, IActionExecutionEnvironment actionEnv, int threadId) { if(depth <= 0) yield break; foreach(IEdge edge in startNode.GetCompatibleOutgoing(incidentEdgeType)) { ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId]; INode adjacentNode = edge.Target; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; int nodeDepth; if(!adjacentNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth)) yield return adjacentNode; if(adjacentNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth) && nodeDepth >= depth - 1) continue; adjacentNodesToMinDepth[adjacentNode] = depth - 1; foreach(INode node in BoundedReachableRec(adjacentNode, depth - 1, incidentEdgeType, adjacentNodeType, graph, adjacentNodesToMinDepth, actionEnv, threadId)) yield return node; } foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId]; INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; int nodeDepth; if(!adjacentNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth)) yield return adjacentNode; if(adjacentNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth) && nodeDepth >= depth - 1) continue; adjacentNodesToMinDepth[adjacentNode] = depth - 1; foreach(INode node in BoundedReachableRec(adjacentNode, depth - 1, incidentEdgeType, adjacentNodeType, graph, adjacentNodesToMinDepth, actionEnv, threadId)) yield return node; } }
private static IEnumerable<IEdge> BoundedReachableEdgesRec(INode startNode, int depth, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, Dictionary<IEdge, SetValueType> visitedEdges, Dictionary<INode, int> adjacentNodesToMinDepth, int threadId) { if(depth <= 0) yield break; foreach(IEdge edge in startNode.GetCompatibleOutgoing(incidentEdgeType)) { INode adjacentNode = edge.Target; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(!visitedEdges.ContainsKey(edge)) { visitedEdges[edge] = null; yield return edge; } int nodeDepth; if(adjacentNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth) && nodeDepth >= depth - 1) continue; adjacentNodesToMinDepth[adjacentNode] = depth - 1; foreach(IEdge reachableEdge in BoundedReachableEdgesRec(adjacentNode, depth - 1, incidentEdgeType, adjacentNodeType, graph, visitedEdges, adjacentNodesToMinDepth, threadId)) yield return reachableEdge; } foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(!visitedEdges.ContainsKey(edge)) { visitedEdges[edge] = null; yield return edge; } int nodeDepth; if(adjacentNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth) && nodeDepth >= depth - 1) continue; adjacentNodesToMinDepth[adjacentNode] = depth - 1; foreach(IEdge reachableEdge in BoundedReachableEdgesRec(adjacentNode, depth - 1, incidentEdgeType, adjacentNodeType, graph, visitedEdges, adjacentNodesToMinDepth, threadId)) yield return reachableEdge; } }
private static IEnumerable<IEdge> ReachableEdgesIncomingRec(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, Dictionary<INode, SetValueType> visitedNodes, int threadId) { foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; yield return edge; if(visitedNodes.ContainsKey(adjacentNode)) continue; visitedNodes.Add(adjacentNode, null); foreach(IEdge reachableEdge in ReachableEdgesIncomingRec(adjacentNode, incidentEdgeType, adjacentNodeType, graph, visitedNodes, threadId)) yield return reachableEdge; } }
private static IEnumerable<IEdge> ReachableEdgesIncomingRec(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, Dictionary<INode, SetValueType> visitedNodes, IActionExecutionEnvironment actionEnv, int threadId) { foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId]; INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; yield return edge; if(visitedNodes.ContainsKey(adjacentNode)) continue; visitedNodes.Add(adjacentNode, null); foreach(IEdge reachableEdge in ReachableEdgesIncomingRec(adjacentNode, incidentEdgeType, adjacentNodeType, graph, visitedNodes, actionEnv, threadId)) yield return reachableEdge; } }
/// <summary> /// Returns whether the end edge is reachable from the start node, via incoming edges, under the type constraints given /// </summary> private static bool IsReachableEdgesIncoming(INode startNode, IEdge endEdge, EdgeType incomingEdgeType, NodeType sourceNodeType, IGraph graph, List<IGraphElement> visitedElems, int threadId) { bool result = false; foreach(IEdge edge in startNode.GetCompatibleIncoming(incomingEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(sourceNodeType)) continue; if(graph.IsInternallyVisited(edge, threadId)) continue; graph.SetInternallyVisited(edge, true, threadId); visitedElems.Add(edge); if(edge.Source == endEdge) return true; if(graph.IsInternallyVisited(adjacentNode, threadId)) continue; graph.SetInternallyVisited(adjacentNode, true, threadId); visitedElems.Add(adjacentNode); result = IsReachableEdgesIncoming(adjacentNode, endEdge, incomingEdgeType, sourceNodeType, graph, visitedElems, threadId); if(result == true) break; } return result; }
public static bool IsIncoming(INode startNode, IEdge endEdge, EdgeType incomingEdgeType, NodeType sourceNodeType, int threadId) { foreach(IEdge edge in startNode.GetCompatibleIncoming(incomingEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(sourceNodeType)) continue; if(edge == endEdge) return true; } return false; }
////////////////////////////////////////////////////////////////////////////////////////////// public static bool IsAdjacent(INode startNode, INode endNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, int threadId) { foreach(IEdge edge in startNode.GetCompatibleOutgoing(incidentEdgeType)) { INode adjacentNode = edge.Target; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(adjacentNode == endNode) return true; } foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(adjacentNode == endNode) return true; } return false; }
/// <summary> /// Returns whether the end node is reachable from the start node, under the type constraints given /// </summary> private static bool IsReachable(INode startNode, INode endNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, List<INode> visitedNodes, int threadId) { bool result = false; foreach(IEdge edge in startNode.GetCompatibleOutgoing(incidentEdgeType)) { INode adjacentNode = edge.Target; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(graph.IsInternallyVisited(adjacentNode, threadId)) continue; if(edge.Target == endNode) return true; graph.SetInternallyVisited(adjacentNode, true, threadId); visitedNodes.Add(adjacentNode); result = IsReachable(adjacentNode, endNode, incidentEdgeType, adjacentNodeType, graph, visitedNodes, threadId); if(result == true) break; } if(!result) { foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; if(graph.IsInternallyVisited(adjacentNode, threadId)) continue; if(edge.Source == endNode) return true; graph.SetInternallyVisited(adjacentNode, true, threadId); visitedNodes.Add(adjacentNode); result = IsReachable(adjacentNode, endNode, incidentEdgeType, adjacentNodeType, graph, visitedNodes, threadId); if(result == true) break; } } return result; }
////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Returns set of nodes adjacent to the start node, under the type constraints given /// </summary> public static Dictionary<INode, SetValueType> Adjacent(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, int threadId) { Dictionary<INode, SetValueType> adjacentNodesSet = new Dictionary<INode, SetValueType>(); foreach(IEdge edge in startNode.GetCompatibleOutgoing(incidentEdgeType)) { INode adjacentNode = edge.Target; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; adjacentNodesSet[adjacentNode] = null; } foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType)) { INode adjacentNode = edge.Source; if(!adjacentNode.InstanceOf(adjacentNodeType)) continue; adjacentNodesSet[adjacentNode] = null; } return adjacentNodesSet; }