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; }
@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 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); }
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; }
void updateHub(Graph graph, double[] newValues, double[] authValues, boolean isDirected, Map<Node, Integer> indices) { double norm = 0; for (Node p : indices.keySet()) { double hub = 0; EdgeIterable edge_iter; if (isDirected) { edge_iter = ((DirectedGraph) graph).getOutEdges(p); } else { edge_iter = graph.getEdges(p); } for (Edge edge : edge_iter) { if (!edge.isSelfLoop()) { Node r = graph.getOpposite(p, edge); hub += authValues[indices.get(r)]; } } newValues[indices.get(p)] = hub; norm += hub * hub; if (isCanceled) { return; } } norm = Math.sqrt(norm); if (norm > 0) { for (int i = 0; i < newValues.length; i++) { newValues[i] = newValues[i] / norm; } } }
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 void setInitialValues(Graph graph, Map<Node, Integer> indicies, double[] pagerankValues, double[] weights, boolean directed, boolean useWeights) { final int N = graph.getNodeCount(); for (Node s : graph.getNodes()) { final int index = indicies.get(s); pagerankValues[index] = 1.0 / N; if (useWeights) { double sum = 0; EdgeIterable eIter; if (directed) { eIter = ((DirectedGraph) graph).getOutEdges(s); } else { eIter = ((UndirectedGraph) graph).getEdges(s); } for (Edge edge : eIter) { if(!edge.isSelfLoop()){ sum += edge.getWeight(); } } weights[index] = sum; } } }