Uses of Class
com.yworks.yfiles.algorithms.Graph

Packages that use Graph

Package	Description
com.yworks.yfiles.algorithms	Provides the yFiles library's most fundamental classes and interfaces that model an efficient graph data type (class Graph), its nodes and edges (classes Node and Edge), and related container structures and iteration mechanisms (class YList and interface ICursor).
com.yworks.yfiles.layout	Provides essential classes and interfaces that constitute the infrastructure for automatic graph layout generation.
com.yworks.yfiles.layout.hierarchic	Provides hierarchic layout style algorithms.
com.yworks.yfiles.layout.labeling	Provides algorithms for the automatic placement of node and edge labels, so called generic labeling algorithms.
com.yworks.yfiles.layout.router	Provides classes for automatic routing of the edges in a graph.
com.yworks.yfiles.layout.router.polyline	Provides classes and interfaces for automatic polyline routing of the edges of a graph.
com.yworks.yfiles.layout.seriesparallel	Provides the series-parallel layout algorithm.

Uses of Graph in com.yworks.yfiles.algorithms

Methods in com.yworks.yfiles.algorithms that return Graph

Modifier and Type	Method and Description
Graph	Graph.createCopy() Creates a copy of this graph.
Graph	Graph.createGraph() Creates an empty base object of the same type as this graph.
Graph	Node.getGraph() Gets the graph this node belongs to.
Graph	LayoutGraphHider.getGraph() Gets the Graph for which this GraphHider was created.
Graph	GraphPartitionManager.getGraph() Gets the Graph for which this partition manager was created.
Graph	Edge.getGraph() Gets the graph this edge belongs to.

Methods in com.yworks.yfiles.algorithms with parameters of type Graph

Modifier and Type	Method and Description
static boolean	ShortestPaths.acyclic(Graph graph, Node s, double[] cost, double[] dist) Solves the single-source shortest path problem for acyclic directed graphs.
static boolean	ShortestPaths.acyclic(Graph graph, Node s, double[] cost, double[] dist, Edge[] pred) Solves the single-source shortest path problem for acyclic directed graphs.
static boolean	ShortestPaths.acyclic(Graph graph, Node s, IDataProvider cost, INodeMap dist, INodeMap pred) Each edge is associated with an arbitrary double value that represents the cost of that edge.
static boolean	ShortestPaths.allPairs(Graph graph, boolean directed, double[] cost, double[][] dist) This method solves the all-pairs shortest path problem for graphs with arbitrary edge costs.
static boolean	ShortestPaths.bellmanFord(Graph graph, Node s, boolean directed, double[] cost, double[] dist) Solves the single-source shortest path problem for arbitrary graphs.
static boolean	ShortestPaths.bellmanFord(Graph graph, Node s, boolean directed, double[] cost, double[] dist, Edge[] pred) Solves the single-source shortest path problem for arbitrary graphs.
static boolean	ShortestPaths.bellmanFord(Graph graph, Node s, boolean directed, IDataProvider cost, INodeMap dist, INodeMap pred) Solves the single-source shortest path problem for arbitrary graphs.
static int	Groups.biconnectedComponentGrouping(Graph graph, INodeMap groupIDs) This method partitions the graph by analyzing its biconnected components.
static EdgeList[]	GraphConnectivity.biconnectedComponents(Graph graph) Calculates the biconnected components of a given undirected graph.
static int	GraphConnectivity.biconnectedComponents(Graph graph, IEdgeMap compNum) Calculates the biconnected components and the articulation points of a given undirected graph and returns the number of biconnected components.
static int	GraphConnectivity.biconnectedComponents(Graph graph, IEdgeMap compNum, INodeMap aPoint) Calculates the biconnected components and the articulation points of a given undirected graph and returns the number of biconnected components.
static Edge	Triangulator.calcDelauneyTriangulation(Graph result, IDataProvider pointData, IEdgeMap revMap) Computes a Delauney triangulation of the given points.
static int	NetworkFlows.calcMaxFlow(Graph graph, Node source, Node sink, IDataProvider eCapDP, IEdgeMap flowEM) Solves a maximum flow problem using the preflow-push method.
static int	NetworkFlows.calcMaxFlowMinCut(Graph graph, Node source, Node sink, IDataProvider eCapDP, IEdgeMap flowEM, INodeMap sourceCutNM) Solves a maximum flow problem using the preflow-push method but additionally marks all nodes that belong to the minimum cut set that is associated with the source of the network.
static boolean	AbortHandler.check(Graph graph) Determines whether or not an algorithm should terminate immediately.
static void	Centrality.closenessCentrality(Graph graph, INodeMap closeness, boolean directed, IDataProvider edgeCosts) Computes the closeness centrality for the nodes of a graph.
static NodeList[]	GraphConnectivity.connectedComponents(Graph graph) Calculates the connected components of a given graph.
static int	GraphConnectivity.connectedComponents(Graph graph, INodeMap compNum) Calculates the connected components of a given graph and returns their number.
static void	AbortHandler.copyHandler(Graph source, Graph target) Attaches the AbortHandler instance of the given source graph to the target graph as well.
Node	Node.createCopy(Graph g) Creates a copy of this node that will be inserted into the given graph.
Edge	Edge.createCopy(Graph g, Node v, Node w) Creates a copy of this edge that will be inserted into the given graph connecting the given source and target nodes.
static AbortHandler	AbortHandler.createForGraph(Graph graph) Creates an handler instance and attaches it to the given graph.
static void	Centrality.degreeCentrality(Graph graph, INodeMap centrality, boolean considerInEdges, boolean considerOutEdges) Computes the degree centrality for the nodes of a given graph.
static NodeList	NodeOrders.dfsCompletion(Graph graph) Calculates an ordering of the nodes identical to the order of node completion events in a depth first search.
static void	NodeOrders.dfsCompletion(Graph graph, int[] order) Calculates an ordering of the nodes identical to the order of node completion events in a depth first search.
static void	ShortestPaths.dijkstra(Graph graph, Node s, boolean directed, double[] cost, double[] dist) Solves the single-source shortest path problem for arbitrary graphs.
static void	ShortestPaths.dijkstra(Graph graph, Node s, boolean directed, double[] cost, double[] dist, Edge[] pred) Solves the single-source shortest path problem for arbitrary graphs.
static void	ShortestPaths.dijkstra(Graph graph, Node s, boolean directed, IDataProvider cost, INodeMap dist, INodeMap pred) Solves the single-source shortest path problem for arbitrary graphs.
static EdgeList	Trees.directTree(Graph tree) Converts the given tree to a directed rooted tree with the given node as root element by reversing some edges.
static EdgeList	Trees.directTree(Graph tree, Node root) Converts the given tree to a directed rooted tree with the given node as root element by reversing some edges.
static void	Centrality.edgeBetweenness(Graph graph, IEdgeMap centrality, boolean directed, IDataProvider edgeCosts) Computes betweenness centrality for each edge of a given graph.
static int	Groups.edgeBetweennessClustering(Graph graph, INodeMap clusterIDs, boolean directed, int minGroupCount, int maxGroupCount, IDataProvider edgeCosts) Partitions the graph into groups using edge betweenness centrality.
static int	Groups.edgeBetweennessClustering(Graph graph, INodeMap clusterIDs, double qualityTimeRatio, int minGroupCount, int maxGroupCount, boolean refine) Partitions the graph into groups using edge betweenness clustering proposed by Girvan and Newman.
static EdgeList[]	Paths.findAllChains(Graph graph, boolean directed) Returns all chains present in the given graph.
static EdgeList	Cycles.findAllCycleEdges(Graph graph, boolean directed) Returns an EdgeList that contains all the edges that are part of at least one directed or undirected simple cycle.
static EdgeList[]	Paths.findAllPaths(Graph graph, Node startNode, Node endNode, boolean directed) Returns all simple directed or undirected paths that connect a start node with an end node.
static EdgeList[]	Paths.findAllPaths(Graph graph, Node startNode, Node endNode, boolean directed, Predicate<EdgeList> filter) A variant of Paths.findAllPaths(Graph, Node, Node, boolean) which returns all simple directed or undirected paths between two given nodes and, additionally, allows to specify a filter for the paths to be returned.
static void	Paths.findAllPaths(Graph graph, Node startNode, Node endNode, IEdgeMap pathEdges) Finds all edges that belong to a directed path from a start node to an end node.
static ICursor	Paths.findAllPathsCursor(Graph graph, Node startNode, Node endNode, boolean directed) A variant of Paths.findAllPaths(Graph, Node, Node, boolean), which returns all simple directed or undirected paths between two given nodes as a special cursor that calculates the next path in the sequence, only when needed.
static EdgeList	Cycles.findCycle(Graph graph, boolean directed) Returns an EdgeList that contains the edges of a cycle found in the given graph.
static void	Cycles.findCycleEdges(Graph graph, IEdgeMap cycleEdges) Marks the edges of a given graph whose removal or reversal would make the graph acyclic while trying to minimize the cost associated with the marked edges.
static void	Cycles.findCycleEdges(Graph graph, IEdgeMap cycleEdges, IDataProvider costDP) Marks the edges of a given graph whose removal or reversal would make the graph acyclic while trying to minimize the cost associated with the marked edges.
static void	Cycles.findCycleEdgesDFS(Graph graph, IEdgeMap cycleEdges) Marks the edges of a given graph whose removal or reversal would make the graph acyclic based on a depth first search.
static EdgeList	Paths.findLongestPath(Graph graph) Returns the longest directed path in a given acyclic weighted graph.
static EdgeList	Paths.findLongestPath(Graph graph, IDataProvider edgeLength) Returns the longest directed path in a given acyclic weighted graph.
static void	Paths.findLongestPaths(Graph graph, Node startNode, IEdgeMap dist, INodeMap maxDist, IEdgeMap predicate) Calculates the longest path from a given node to all other node in a given directed acyclic graph.
static EdgeList	Paths.findLongPath(Graph graph) Returns an EdgeList containing the edges of an undirected simple path within the given graph.
static boolean	Paths.findPath(Graph graph, NodeList topSort, Node startNode, Node endNode, IEdgeMap predicate) Returns whether or not a directed path from a start node to another node in an acyclic graph exists.
static EdgeList	Paths.findPath(Graph graph, Node startNode, Node endNode, boolean directed) Returns an EdgeList containing the edges of a path from the given start node to the given end node, if such a path exists.
static void	ShortestPaths.findShortestUniformPaths(Graph graph, Node start, IDataProvider targetMap, boolean directed, int maxLength, EdgeList pathEdges, NodeList pathNodes) Finds all nodes and edges that belong to a shortest path from a start node to a set of target nodes in the graph not farther away than a given distance.
static void	ShortestPaths.findShortestUniformPaths(Graph graph, Node start, Node end, boolean directed, IEdgeMap pathMap) Marks all edges that belong to a shortest path from start node to target node.
static boolean	Bipartitions.getBipartition(Graph graph, INodeMap markMap) Calculates a bipartition of the given graph, if one exists.
static Node	Trees.getCenterRoot(Graph tree) Returns the center node of an undirected tree.
static AbortHandler	AbortHandler.getFromGraph(Graph graph) Returns an AbortHandler instance for the given graph.
static NodeList	IndependentSets.getIndependentSet(Graph conflictGraph) Calculates an independent set for a given graph.
static NodeList[]	IndependentSets.getIndependentSets(Graph conflictGraph) Partitions the set of nodes of the given graph into independent sets.
static NodeList[]	Bfs.getLayers(Graph graph, IDataProvider isCoreNode) Returns the layers of nodes constructed by a breadth first search.
static NodeList[]	Bfs.getLayers(Graph graph, IDataProvider isCoreNode, INodeMap layerIDMap) Returns the layers of nodes constructed by a breadth first search.
static NodeList[]	Bfs.getLayers(Graph graph, NodeList coreNodes) Returns the layers of nodes calculated by a breadth first search.
static NodeList[]	Bfs.getLayers(Graph graph, NodeList coreNodes, BfsDirection direction, INodeMap layerIDMap) Returns the layers of nodes constructed by a directed/undirected breadth first search where the maximum number of layers is restricted.
static NodeList[]	Bfs.getLayers(Graph graph, NodeList coreNodes, BfsDirection direction, INodeMap layerIDMap, int maxLayers) Returns the layers of nodes constructed by a directed/undirected breadth first search where the maximum number of layers is restricted.
static NodeList[]	Bfs.getLayers(Graph graph, NodeList coreNodes, boolean directed, INodeMap layerIDMap) Returns the layers of nodes constructed by a directed/undirected breadth first search where the maximum number of layers is restricted.
static NodeList[]	Bfs.getLayers(Graph graph, NodeList coreNodes, boolean directed, INodeMap layerIDMap, int maxLayers) Returns the layers of nodes constructed by a directed/undirected breadth first search where the maximum number of layers is restricted.
static NodeList[]	Bfs.getLayers(Graph graph, NodeList coreNodes, INodeMap layerIDMap) Returns the layers of nodes constructed by a breadth first search.
static NodeList	Trees.getLeafNodes(Graph tree, boolean directedRootedTree) Returns all leaf nodes of the given tree.
static Node	Trees.getNearestCommonAncestor(Graph tree, Node root, boolean rootedDownward, NodeList nodes) Returns the nearest common ancestor of a subset of nodes within a directed rooted tree.
static NodeList	GraphConnectivity.getNeighbors(Graph graph, NodeList startNodes, int maxDistance) Determines the direct or indirect neighbors of a given set of nodes.
static NodeList	GraphConnectivity.getPredecessors(Graph graph, NodeList startNodes, int maxDistance) Determines the direct or indirect predecessors of a given list of nodes.
static Node	Trees.getRoot(Graph tree) Returns a possible root for the given (undirected) tree.
static void	Trees.getSubTreeDepths(Graph tree, INodeMap subtreeDepthMap) Returns the depths of each subtree of a rooted directed tree.
static void	Trees.getSubTreeSizes(Graph tree, INodeMap subtreeSizeMap) Returns the size (number of nodes) of each subtree of a rooted directed tree.
static NodeList	GraphConnectivity.getSuccessors(Graph graph, NodeList startNodes, int maxDistance) Determines the direct or indirect successors of a given list of nodes.
static EdgeList[]	Trees.getTreeEdges(Graph graph) Returns an array of EdgeList objects each containing edges that belong to a maximal directed subtree of the given graph.
static EdgeList[]	Trees.getTreeEdges(Graph graph, NodeList[] treeNodes) Returns an array of EdgeList objects each containing edges that belong to a maximal directed subtree of the given graph.
static NodeList[]	Trees.getTreeNodes(Graph graph) Returns an array of NodeList objects each containing nodes that belong to a maximal directed subtree of the given graph.
static NodeList[]	Trees.getUndirectedTreeNodes(Graph graph) Returns an array of NodeList objects each containing nodes that belong to a maximal undirected subtree of the given graph.
static Node	Trees.getWeightedCenterNode(Graph tree) Finds a node used by the greatest number of all (undirected) paths interconnecting all nodes with each other.
static Node	Trees.getWeightedCenterNode(Graph tree, INodeMap intWeight) Finds a node used by the greatest number of all (undirected) paths interconnecting all nodes with each other.
static void	Centrality.graphCentrality(Graph graph, INodeMap centrality, boolean directed, IDataProvider edgeCosts) Computes the graph centrality for the nodes of a graph.
static boolean	AbortHandler.hasHandler(Graph graph) Determines whether or not an AbortHandler instance is attached to the given graph.
static void	LayoutGraphHider.hideSubgraph(Graph graph, IEdgeCursor ec) Hides the subgraph induced by the given edges from the given graph.
static Groups.Dendrogram	Groups.hierarchicalClustering(Graph graph, Groups.INodeDistanceProvider distances, Linkage linkage) Partitions the graph into clusters based on hierarchical clustering.
static int	Groups.hierarchicalClustering(Graph graph, INodeMap clusterIDs, Groups.INodeDistanceProvider distances, Linkage linkage, double cutOff) Partitions the graph into clusters based on hierarchical clustering, while the dendrogram is cut based on a given cut-off value.
static int	Groups.hierarchicalClustering(Graph graph, int maxCluster, INodeMap clusterIDs, Groups.INodeDistanceProvider distances, Linkage linkage) Partitions the graph into clusters based on hierarchical clustering, while the dendrogram is cut based on a given maximum number of clusters.
static boolean	GraphChecker.isAcyclic(Graph graph) Checks whether or not the given directed graph is acyclic.
static boolean	GraphConnectivity.isBiconnected(Graph graph) Checks whether or not the given undirected graph is biconnected.
static boolean	GraphChecker.isBiconnected(Graph graph) Checks whether or not the given undirected graph is biconnected.
static boolean	GraphChecker.isBipartite(Graph graph) Checks whether or not the given undirected graph is bipartite.
static boolean	Bipartitions.isBipartite(Graph graph) Determines whether or not the given graph is bipartite.
static boolean	GraphConnectivity.isConnected(Graph graph) Checks whether or not the given graph is connected.
static boolean	GraphChecker.isConnected(Graph graph) Checks whether or not the given graph is connected.
static boolean	GraphChecker.isCyclic(Graph graph) Checks whether or not the given directed graph is cyclic.
static boolean	Trees.isForest(Graph graph) Checks whether or not the given graph is a forest, that is, a graph whose connected components are directed rooted trees.
static boolean	GraphChecker.isForest(Graph graph) Checks whether the given graph is a forest.
static boolean	Trees.isForest(Graph graph, boolean directedRootedTree) Checks whether or not the given graph is a forest.
static boolean	GraphChecker.isMultipleEdgeFree(Graph graph) Checks whether or not the given undirected graph contains no multiple edges.
static boolean	Trees.isNaryTree(Graph graph, int n) Checks whether or not the given graph is a directed rooted tree in which each node has a maximum of n children.
static boolean	GraphChecker.isNaryTree(Graph graph, int n) Checks whether or not the given graph is a directed rooted tree where each node has a maximum of n children.
static boolean	PlanarEmbedding.isPlanar(Graph graph) Return whether or not the given graph is planar.
static boolean	GraphChecker.isPlanar(Graph graph) Checks whether or not the given graph is planar.
static boolean	Trees.isRootedTree(Graph graph) Checks whether or not the given graph is a directed rooted tree.
static boolean	GraphChecker.isRootedTree(Graph graph) Checks whether or not the given directed graph is a directed rooted tree.
static boolean	GraphChecker.isSelfLoopFree(Graph graph) Checks whether or not the given graph contains no self-loops.
static boolean	GraphChecker.isSimple(Graph graph) Checks whether or not the given directed graph is simple.
static boolean	GraphConnectivity.isStronglyConnected(Graph graph) Checks whether or not the given directed graph is strongly connected.
static boolean	GraphChecker.isStronglyConnected(Graph graph) Checks whether or not the given directed graph is strongly connected.
static boolean	Trees.isTree(Graph graph) Checks whether or not the given graph is an undirected tree.
static boolean	GraphChecker.isTree(Graph graph) Checks whether or not the given graph is an undirected tree.
static int	Groups.kMeansClustering(Graph graph, INodeMap clusterIDs, IDataProvider nodePositions, DistanceMetric distanceMetric, int k) Partitions the graph into clusters using k-means clustering algorithm.
static int	Groups.kMeansClustering(Graph graph, INodeMap clusterIDs, IDataProvider nodePositions, DistanceMetric distanceMetric, int k, int iterations) Partitions the graph into clusters using k-means clustering algorithm.
static int	Groups.kMeansClustering(Graph graph, INodeMap clusterIDs, IDataProvider nodePositions, DistanceMetric distanceMetric, int k, int iterations, YPoint[] centroids) Partitions the graph into clusters using k-means clustering algorithm.
static EdgeList	SpanningTrees.kruskal(Graph graph, IDataProvider cost) Calculates a minimum spanning tree for the given graph.
static YList	ShortestPaths.kShortestPaths(Graph graph, IDataProvider costDP, Node start, Node end, int k) This method finds the k shortest paths connecting a pair of nodes in a directed graph with non-negative edge costs.
static ICursor	ShortestPaths.kShortestPathsCursor(Graph graph, IDataProvider costDP, Node start, Node end, int k) A variant of ShortestPaths.kShortestPaths(Graph, IDataProvider, Node, Node, int) that returns the result as a special cursor that calculates the next path in the sequence only when needed.
static EdgeList	GraphConnectivity.makeBiconnected(Graph graph) Makes the given graph biconnected by inserting a minimum number of edges in the graph.
static EdgeList	GraphConnectivity.makeConnected(Graph graph) Makes a graph connected by adding additional edges to the graph.
static int	NetworkFlows.minCostFlow(Graph graph, IDataProvider lCapDP, IDataProvider uCapDP, IDataProvider cost0DP, IDataProvider supplyDP, IEdgeMap flowEM, INodeMap dualsNM) Solves a minimum cost flow problem with a capacity scaling algorithm.
static int	NetworkFlows.minCostFlow(Graph graph, IDataProvider uCapDP, IDataProvider cost0DP, IDataProvider supplyDP, IEdgeMap flowEM, INodeMap dualsNM) Uses method NetworkFlows.minCostFlow(Graph, IDataProvider, IDataProvider, IDataProvider, IDataProvider, IEdgeMap, INodeMap) to solve a minimum cost flow problem.
static int	NetworkFlows.minCostFlow(Graph graph, Node s, Node t, IDataProvider uCapDP, IDataProvider cost0DP, IEdgeMap flowEM, INodeMap dualsNM) Solves a minimum cost maximum flow problem.
static EdgeList	SpanningTrees.minimum(Graph graph, IDataProvider cost) Calculates a minimum spanning tree for the given graph.
static void	Centrality.nodeBetweenness(Graph graph, INodeMap centrality, boolean directed, IDataProvider edgeCosts) Computes betweenness centrality for each node of a given graph.
static void	Centrality.nodeEdgeBetweenness(Graph graph, INodeMap nodeCentrality, IEdgeMap edgeCentrality, boolean directed, IDataProvider edgeCosts) Computes betweenness centrality for each node and edge of a given graph.
INodeCursor	INodeSequencer.nodes(Graph graph) Returns a cursor that grants access to all nodes of the given graph in some order.
static void	Centrality.normalize(Graph graph, IEdgeMap map) Normalizes the double values of a given IEdgeMap by dividing each of them by the maximum of all values (maximum norm).
static void	Centrality.normalize(Graph graph, INodeMap map) Normalizes the double values of a given INodeMap by dividing each of them by the maximum of all values (maximum norm).
static EdgeList	SpanningTrees.prim(Graph graph, IDataProvider cost) Calculates a minimum spanning tree for the given graph.
static void	GraphConnectivity.reachable(Graph graph, Node start, boolean directed, boolean[] reached) Determines the set of nodes that are reachable from a given node when a set of edges that cannot be traversed is specified.
static void	GraphConnectivity.reachable(Graph graph, Node start, boolean directed, boolean[] reached, boolean[] forbidden) Determines the set of nodes that are reachable from a given node when a set of edges that cannot be traversed is specified.
static void	AbortHandler.removeFromGraph(Graph graph) Removes any attached AbortHandler instance from the given graph.
static EdgeList[]	ShortestPaths.shortestPair(Graph graph, Node source, Node target, boolean directed, IDataProvider costDP) Returns two edge-disjoint paths in a non-negatively weighted directed graph, such that both paths connect nodes s and t and have minimum total length.
static int	RankAssignments.simple(Graph graph, INodeMap rank, IEdgeMap minLength) This method quickly calculates a tight tree given a maximum time duration for the algorithm.
static int	RankAssignments.simple(Graph graph, INodeMap rank, IEdgeMap minLength, long maximalDuration) This method quickly calculates a tight tree given a maximum time duration for the algorithm.
static int	RankAssignments.simple(Graph graph, int[] rank, int[] minLength) Like RankAssignments.simple(Graph, INodeMap, IEdgeMap, long), but arrays are used instead of INodeMaps and IEdgeMaps.
static int	RankAssignments.simple(Graph graph, int[] rank, int[] minLength, long maximalDuration) Like RankAssignments.simple(Graph, INodeMap, IEdgeMap, long), but arrays are used instead of INodeMaps and IEdgeMaps.
static int	RankAssignments.simplex(Graph graph, INodeMap layer, IDataProvider w, IDataProvider minLength) Solves the rank assignment problem using the simplex method given a maximum time duration for the algorithm.
static int	RankAssignments.simplex(Graph graph, INodeMap layer, IDataProvider w, IDataProvider minLength, IEdgeMap tree, Node _root, boolean validRanking) Similar to RankAssignments.simplex(Graph, INodeMap, IDataProvider, IDataProvider, long) but, additionally, it is possible to provide a valid initial tree solution for the problem.
static int	RankAssignments.simplex(Graph graph, INodeMap layer, IDataProvider w, IDataProvider minLength, IEdgeMap tree, Node _root, boolean validRanking, long maximalDuration) Similar to RankAssignments.simplex(Graph, INodeMap, IDataProvider, IDataProvider, long) but, additionally, it is possible to provide a valid initial tree solution for the problem.
static int	RankAssignments.simplex(Graph graph, INodeMap layer, IDataProvider w, IDataProvider minLength, long maximalDuration) Solves the rank assignment problem using the simplex method given a maximum time duration for the algorithm.
static boolean	ShortestPaths.singleSource(Graph graph, Node s, boolean directed, double[] cost, double[] dist) This method solves the single-source shortest path problem for arbitrary graphs.
static boolean	ShortestPaths.singleSource(Graph graph, Node s, boolean directed, double[] cost, double[] dist, Edge[] pred) This method solves the single-source shortest path problem for arbitrary graphs.
static boolean	ShortestPaths.singleSource(Graph graph, Node s, boolean directed, IDataProvider cost, INodeMap dist, INodeMap pred) This method solves the single-source shortest path problem for arbitrary graphs.
static EdgeList	ShortestPaths.singleSourceSingleSink(Graph graph, Node s, Node t, boolean directed, double[] cost) Similar to ShortestPaths.singleSourceSingleSink(Graph, Node, Node, boolean, double[], Edge[]) but instead of returning the shortest distance between the source and sink the actual shortest edge path between these nodes will be returned.
static double	ShortestPaths.singleSourceSingleSink(Graph graph, Node s, Node t, boolean directed, double[] cost, Edge[] pred) This method solves the single-source single-sink shortest path problem for arbitrary graphs.
static EdgeList	ShortestPaths.singleSourceSingleSink(Graph graph, Node s, Node t, boolean directed, IDataProvider cost) Similar to ShortestPaths.singleSourceSingleSink(Graph, Node, Node, boolean, IDataProvider, INodeMap) but instead of returning the shortest distance between the source and sink the actual shortest edge path between these nodes will be returned.
static double	ShortestPaths.singleSourceSingleSink(Graph graph, Node s, Node t, boolean directed, IDataProvider cost, INodeMap pred) Like ShortestPaths.singleSourceSingleSink(Graph, Node, Node, boolean, double[], Edge[]) but uses INodeMaps and IDataProviders instead of arrays.
static Node[]	Sorting.sortNodesByDegree(Graph graph) Sorts the nodes of a given graph by degree in ascending order.
static Node[]	Sorting.sortNodesByIntKey(Graph graph, IDataProvider keys) Sorts the nodes of a given graph by an integer key associated with each node through a IDataProvider.
static NodeList	NodeOrders.st(Graph graph) Assigns an st-ordering to the nodes of a biconnected graph.
static void	NodeOrders.st(Graph graph, int[] stOrder) Assigns an st-ordering to the nodes of a biconnected graph given the edge between source node s and sink node t.
static void	NodeOrders.st(Graph graph, int[] stOrder, Edge stEdge) Assigns an st-ordering to the nodes of a biconnected graph given the edge between source node s and sink node t.
void	Dfs.start(Graph graph) Starts a depth first search on the given graph.
void	Dfs.start(Graph graph, Node start) Starts a depth first search from a given Node of the input graph.
static NodeList[]	GraphConnectivity.stronglyConnectedComponents(Graph graph) Calculates the strongly connected components of a given graph.
static int	GraphConnectivity.stronglyConnectedComponents(Graph graph, INodeMap compNum) Calculates the strongly connected components of a given graph and returns their number.
static EdgeList[]	GraphConnectivity.toEdgeListArray(Graph graph, IEdgeMap compNum, int maxCompNum) Transforms the return values of GraphConnectivity.biconnectedComponents(Graph, IEdgeMap, INodeMap) to an array of EdgeLists, like it is returned by GraphConnectivity.biconnectedComponents(Graph).
static NodeList	NodeOrders.toNodeList(Graph graph, int[] order) Converts an array-based result returned by a method of this class to a NodeList that contains all nodes in the order provided by the given array.
static NodeList[]	GraphConnectivity.toNodeListArray(Graph graph, INodeMap compNum, int maxCompNum) Transforms the return values of method GraphConnectivity.connectedComponents(Graph, INodeMap) to an array of NodeLists, like it is returned by GraphConnectivity.connectedComponents(Graph).
static void	NodeOrders.toNodeMap(Graph graph, int[] order, INodeMap result) Copies an array-based result returned by a method of this class to a INodeMap that will provide values of basic type int.
static NodeList	NodeOrders.topological(Graph graph) Returns a topological ordering of the nodes of a directed acyclic graph.
static boolean	NodeOrders.topological(Graph graph, int[] order) Assigns a topological ordering to the nodes of a directed acyclic graph.
static void	Transitivity.transitiveClosure(Graph graph) Calculates the transitive closure for a directed acyclic graph.
static void	Transitivity.transitiveClosure(Graph graph, EdgeList addedEdges) Calculates the transitive closure for a directed acyclic graph.
static void	Transitivity.transitiveReduction(Graph graph) Calculates the transitive reduction for a directed acyclic graph.
static void	Transitivity.transitiveReduction(Graph graph, EdgeList transitiveEdges) Calculates the transitive reduction for a directed acyclic graph.
static Edge	Triangulator.triangulatePoints(Graph result, IDataProvider pointData, IEdgeMap reverseEdgeMap) Computes a triangulation of the given points.
static Edge	Triangulator.triangulatePoints(YList points, Graph result, INodeMap resultMap, IEdgeMap reverseEdgeMap) Computes a triangulation of the given points.
static void	LayoutGraphHider.unhideSubgraph(Graph graph, IEdgeCursor ec) Unhides the subgraph induced by the given edges in the given graph.
static EdgeList	SpanningTrees.uniform(Graph graph) Calculates a spanning tree for the given graph in which each edge has a uniform cost of 1.0.
static void	ShortestPaths.uniform(Graph graph, Node s, boolean directed, double[] dist) Solves the single-source shortest path problem for arbitrary graphs in which each edge has a uniform cost of 1.0.
static void	ShortestPaths.uniform(Graph graph, Node s, boolean directed, double[] dist, Edge[] pred) Solves the single-source shortest path problem for arbitrary graphs in which each edge has a uniform cost of 1.0.
static void	ShortestPaths.uniform(Graph graph, Node s, boolean directed, INodeMap dist, INodeMap pred) Like ShortestPaths.uniform(Graph, Node, boolean, double[], Edge[]) but uses INodeMaps instead of arrays.
static double[]	ShortestPaths.uniformCost(Graph graph) Convenience method that returns an array containing uniform edge costs of 1.0 for each edge of the given graph.
static void	Centrality.weightCentrality(Graph graph, INodeMap centrality, boolean considerInEdges, boolean considerOutEdges, IDataProvider edgeWeights) Computes the weight centrality for the nodes of a graph.

Constructors in com.yworks.yfiles.algorithms with parameters of type Graph

Constructor and Description
DataProviderOverlayManager(Graph graph) Creates a data provider overlay for the given graph instance.
Edge(Graph g, Node v, Edge e1, Node w, Edge e2, GraphElementInsertion d1, GraphElementInsertion d2) Creates a new edge that belongs to the given graph.
Graph(Graph graph) Instantiates a new Graph object as a partial copy of the given graph.
Graph(Graph graph, ICursor subNodes) Instantiates a new Graph object as a partial copy of the given graph.
GraphPartitionManager(Graph graph, IDataProvider partitionId) Instantiates a new GraphPartitionManager for the given graph.
LayoutGraphHider(Graph g) Instantiates a new GraphHider for the given graph.
Node(Graph g) Instantiates a new Node object that will be part of the given graph.
PlanarEmbedding(Graph graph) Creates a new embedding for the specified planar graph.

Uses of Graph in com.yworks.yfiles.layout

Subclasses of Graph in com.yworks.yfiles.layout

Modifier and Type	Class and Description
class	CopiedLayoutGraph A CopiedLayoutGraph is a LayoutGraph that serves as a copy of another graph with layout information.
class	DefaultLayoutGraph DefaultLayoutGraph is a default implementation of LayoutGraph which holds the complete layout information about the graph and its elements.
class	LayoutGraph A LayoutGraph is a Graph with attached layout information that basically represents a drawing of a graph.

Methods in com.yworks.yfiles.layout that return Graph

Modifier and Type	Method and Description
Graph	GroupingSupport.getGraph() Gets the Graph instance for which this GroupingSupport object provides hierarchy information.
Graph	YGraphAdapter.getYGraph() Gets the graph instance that is created during the constructor call.

Methods in com.yworks.yfiles.layout with parameters of type Graph

Modifier and Type	Method and Description
static void	Swimlanes.arrangeSwimlanes(Graph graph, IDataProvider node2Swimlane) Calculates an ordering of the swimlanes.
static void	Swimlanes.arrangeSwimlanes(Graph graph, IDataProvider node2Swimlane, int iterations, SwimlanesMode mode) Calculates an ordering of the swimlanes considering the specified ordering mode.
protected INodeMap	GroupingSupport.createInfoMap(Graph graph) Creates a INodeMap to store hierarchy information for each node.
protected void	GroupingSupport.disposeInfoMap(Graph graph, INodeMap infoMap) Disposes of the INodeMap created to store hierarchy information for each node.
static void	NormalizeGraphElementOrderStage.fillComparableMapFromGraph(Graph graph, IDataMap comparableNodeMap, IDataMap comparableEdgeMap) Assigns comparable values for each node and edge.
protected void	ParallelEdgeRouter.findAndHideParallelEdges(Graph graph) Hides all parallel edges leaving a master edge in the graph.
static PartitionGrid	PartitionGrid.getPartitionGrid(Graph graph) Returns the PartitionGrid instance associated with the given graph.
static boolean	PartitionGrid.hasAtLeastTwoNonEmptyRows(Graph graph) Checks whether or not the nodes of the graph are assigned to at least two different partition rows.
static boolean	GroupingSupport.isFlat(Graph graph) Returns whether or not the given graph is flat.
static boolean	GroupingSupport.isGrouped(Graph graph) Returns whether or not the given graph is grouped.
void	EdgeLabelOrientationSupport.postProcessLabel(Graph graph, LabelLayoutData label) Restores the original preferred placement and updates the label rotation according to the layout orientation.
void	EdgeLabelOrientationSupport.preProcessLabel(Graph graph, LabelLayoutData label, Direction segmentDirection) Prepares the label for the core layout algorithm.
void	EdgeLabelOrientationSupport.replaceAmbiguousLabelDescriptors(Graph graph) Replaces the PreferredPlacementDescriptors of all edge labels in the given graph with non-ambiguous descriptors.
void	EdgeLabelOrientationSupport.resetAmbiguousLabelDescriptors(Graph graph) Restores the PreferredPlacementDescriptors of all edge labels in the given graph with their original descriptors.

Constructors in com.yworks.yfiles.layout with parameters of type Graph

Constructor and Description
GroupingSupport(Graph graph) Creates a new GroupingSupport instance that represents the hierarchy of the graph.

Uses of Graph in com.yworks.yfiles.layout.hierarchic

Methods in com.yworks.yfiles.layout.hierarchic with parameters of type Graph

Modifier and Type	Method and Description
int	WeightedLayerer.assignLayers(Graph graph, INodeMap layerID) Assigns all nodes of the graph to layers.
int	WeightedLayerer.assignLayersFast(Graph graph, INodeMap layerID) Assigns all nodes of the graph to layers.
ILayerConstraintFactory	HierarchicLayoutCore.createLayerConstraintFactory(Graph graph) Creates a layer constraint factory that allows to create hints that affect the assignment of the nodes to layers.
ILayerConstraintFactory	HierarchicLayout.createLayerConstraintFactory(Graph graph) Returns a ILayerConstraintFactory instance that can be used for specifying layer constraints for the given graph.
ISequenceConstraintFactory	HierarchicLayoutCore.createSequenceConstraintFactory(Graph graph) Creates sequence constraints that affect the sequence of the nodes within each layer.
void	WeightedLayerer.makeDFSAcyclic(Graph graph, EdgeList reversedEdges) Removes cycles from the graph using a depth first search.
int	GivenLayersLayerer.normalize(Graph graph, IDataProvider layerId, IDataAcceptor normalizedLayerId) Convenience method that removes empty layers and ensures that the smallest layer has value 0.

Uses of Graph in com.yworks.yfiles.layout.labeling

Fields in com.yworks.yfiles.layout.labeling declared as Graph

Modifier and Type	Field and Description
protected Graph	AbstractMISLabeling.conflictGraph The conflict graph modeling LabelCandidates as nodes and edges between them as conflicts, i.e., overlaps among candidates.

Uses of Graph in com.yworks.yfiles.layout.router

Methods in com.yworks.yfiles.layout.router with parameters of type Graph

Modifier and Type	Method and Description
static EdgeList[]	BusRepresentations.toEdgeLists(Graph graph, IDataProvider hubMarker) Calculates for every bus represented by hubs a list of all of its edges.

Uses of Graph in com.yworks.yfiles.layout.router.polyline

Methods in com.yworks.yfiles.layout.router.polyline with parameters of type Graph

Modifier and Type	Method and Description
protected boolean	EdgeRouter.isAffected(Edge edge, Graph graph) Returns whether or not a given edge is selected.

Uses of Graph in com.yworks.yfiles.layout.seriesparallel

Methods in com.yworks.yfiles.layout.seriesparallel with parameters of type Graph

Modifier and Type	Method and Description
static boolean	SeriesParallelLayout.isSeriesParallelGraph(Graph graph) Determines whether or not the given graph has a series-parallel structure.