@Override public Number[] getValues(Graph graph) { DirectedGraph dgraph = (DirectedGraph) graph; List<Integer> values = new ArrayList<>(dgraph.getNodeCount()); for (Node n : dgraph.getNodes()) { int degree = 0; for (Edge e : dgraph.getOutEdges(n)) { if (dgraph.getMutualEdge(e) != null) { degree++; } } values.add(degree); } return values.toArray(new Number[0]); }
@Override public Number[] getValues(Graph graph) { DirectedGraph dgraph = (DirectedGraph) graph; List<Integer> values = new ArrayList<>(dgraph.getNodeCount()); for (Node n : dgraph.getNodes()) { int degree = dgraph.getInDegree(n); values.add(degree); } return values.toArray(new Number[0]); }
@Override public Number[] getValues(Graph graph) { DirectedGraph dgraph = (DirectedGraph) graph; List<Integer> values = new ArrayList<>(dgraph.getNodeCount()); for (Node n : dgraph.getNodes()) { int degree = dgraph.getOutDegree(n); values.add(degree); } return values.toArray(new Number[0]); }
directedGraph.addNode(n0); directedGraph.addNode(n1); directedGraph.addNode(n2); directedGraph.addEdge(e1); directedGraph.addEdge(e2); directedGraph.addEdge(e3); System.out.println("Nodes: " + directedGraph.getNodeCount() + " Edges: " + directedGraph.getEdgeCount()); for (Node n : directedGraph.getNodes()) { Node[] neighbors = directedGraph.getNeighbors(n).toArray(); System.out.println(n.getLabel() + " has " + neighbors.length + " neighbors"); for (Edge e : directedGraph.getEdges()) { System.out.println(e.getSource().getId() + " -> " + e.getTarget().getId()); Node node2 = directedGraph.getNode("n2"); System.out.println("Node2 degree: " + directedGraph.getDegree(node2)); for (Node n : directedGraph.getNodes().toArray()) { directedGraph.removeNode(n);
@Override public void compute() { graph.readLock(); try { for (Node node : graph.getNodes()) { distances.put(node, Double.POSITIVE_INFINITY); nodeCount++; for (Edge edge : graph.getEdges()) { Node target = edge.getTarget(); if (relax(edge)) { EdgeIterable edgesIterable = graph.getEdges(); for (Edge edge : edgesIterable) { if (distances.get(edge.getSource()) + edgeWeight(edge) < distances.get(edge.getTarget())) { graph.readUnlockAll();
System.out.println("Nodes: " + graph.getNodeCount() + " Edges: " + graph.getEdgeCount()); System.out.println("Nodes: " + graph.getNodeCount() + " Edges: " + graph.getEdgeCount()); System.out.println("Nodes: " + graph.getNodeCount() + " Edges: " + graph.getEdgeCount()); System.out.println("Nodes: " + graph.getNodeCount() + " Edges: " + graph.getEdgeCount());
stronglyCount = 0; int N = graph.getNodeCount(); int[] index = new int[N]; int[] low_index = new int[N]; NodeIterable iter = graph.getNodes(); for (Node u : iter) { if (index[indices.get(u)] == 0) {
@Override public boolean evaluate(Graph graph, Node node) { DirectedGraph dgraph = (DirectedGraph) graph; int degree = 0; for (Edge e : dgraph.getOutEdges(node)) { if (dgraph.getMutualEdge(e) != null) { degree++; } } return range.isInRange(degree); }
@Override public Number getValue(Element element, Graph gr) { return ((DirectedGraph)gr).getOutDegree((Node) element); }
public static Node[] getPredecessors(DirectedGraph graph, Node[] nodes) { Set<Node> nodeTree = new HashSet<>(); graph.readLock(); try { for (Node n : nodes) { nodeTree.addAll(graph.getPredecessors(n).toCollection()); } } finally { graph.readUnlock(); } //remove original nodes for (Node n : nodes) { nodeTree.remove(n); } return nodeTree.toArray(new Node[0]); }
int indegree = directedGraph.getInDegree(n); int outdegree = directedGraph.getOutDegree(n);
public static Node[] getSuccessors(DirectedGraph graph, Node[] nodes) { Set<Node> nodeTree = new HashSet<>(); graph.readLock(); try { for (Node n : nodes) { nodeTree.addAll(graph.getSuccessors(n).toCollection()); } } finally { graph.readUnlock(); } //remove original nodes for (Node n : nodes) { nodeTree.remove(n); } return nodeTree.toArray(new Node[0]); }
@Override public boolean evaluate(Graph graph, Edge edge) { if(edge.isDirected()) { DirectedGraph directedGraph = (DirectedGraph)graph; return directedGraph.getMutualEdge(edge) != null; } return false; }
@Override public Number getValue(Element element, Graph gr) { return ((DirectedGraph)gr).getInDegree((Node) element); }
private HashMap<Node, EdgeWrapper> createNeighbourTable(Graph graph, Node node, HashMap<Node, Integer> indicies, ArrayWrapper[] networks, boolean directed) { HashMap<Node, EdgeWrapper> neighborTable = new HashMap<>(); if (!directed) { for (Edge edge : graph.getEdges(node)) { Node neighbor = graph.getOpposite(node, edge); neighborTable.put(neighbor, new EdgeWrapper(1, networks[indicies.get(neighbor)])); } } else { for (Node neighbor : ((DirectedGraph) graph).getPredecessors(node)) { neighborTable.put(neighbor, new EdgeWrapper(1, networks[indicies.get(neighbor)])); } for (Edge out : ((DirectedGraph) graph).getOutEdges(node)) { Node neighbor = out.getTarget(); EdgeWrapper ew = neighborTable.get(neighbor); if (ew == null) { neighborTable.put(neighbor, new EdgeWrapper(1, network[indicies.get(neighbor)])); } else { ew.count++; } } } return neighborTable; }
private LinkedList<LinkedList<Node>> tarjans(LinkedList<LinkedList<Node>> components, LinkedList<Node> S, DirectedGraph graph, Node f, int[] index, int[] low_index, HashMap<Node, Integer> indices) { int id = indices.get(f); index[id] = count; low_index[id] = count; count++; S.addFirst(f); EdgeIterable edgeIter = graph.getOutEdges(f); for (Edge e : edgeIter) { Node u = graph.getOpposite(f, e); int x = indices.get(u); if (index[x] == 0) { tarjans(components, S, graph, u, index, low_index, indices); low_index[id] = Math.min(low_index[x], low_index[id]); } else if (S.contains(u)) { low_index[id] = Math.min(low_index[id], index[x]); } } LinkedList<Node> currentComponent = new LinkedList<>(); if (low_index[id] == index[id]) { Node v = null; while (v != f) { v = S.removeFirst(); currentComponent.add(v); } components.add(currentComponent); } return components; }
private EdgeIterable getEdgeIter(Graph graph, Node v, boolean directed) { EdgeIterable edgeIter; if (directed) { edgeIter = ((DirectedGraph) graph).getOutEdges(v); } else { edgeIter = graph.getEdges(v); } return edgeIter; }
double totalInWeight = 0; double totalOutWeight = 0; for (Edge e : directedGraph.getEdges(n)) { if (e.getSource().equals(n)) { totalOutWeight += e.getWeight();
System.out.println("Nodes: " + graph.getNodeCount()); System.out.println("Edges: " + graph.getEdgeCount());
protected int calculateOutDegree(DirectedGraph directedGraph, Node n) { return directedGraph.getOutDegree(n); }