private boolean directedCompute() { SortedSet<Integer> degrees = new TreeSet<Integer>(); for (IElement iE : g.getNodes()) { DirectedNode n = (DirectedNode) iE; int degree = n.getOutDegree(); degrees.add(degree); if (nodesSortedByDegree.containsKey(degree)) { this.nodesSortedByDegree.get(degree).add(n); } else { LinkedList<Node> temp = new LinkedList<>(); temp.add(n); this.nodesSortedByDegree.put(degree, temp); } } HashSet<Node> currentRichClub = new HashSet<Node>(); int currentRichClubSize = 0; int size = degrees.size(); for (int i = 0; i < size; i++) { int currentDegree = degrees.last(); degrees.remove(currentDegree); LinkedList<Node> current = this.nodesSortedByDegree.get(currentDegree); currentRichClubSize += current.size(); this.nodesSortedByDegree.remove(currentDegree); if (currentRichClubSize >= this.richClubSize) { int seperateAT = current.size() - (currentRichClubSize - this.richClubSize); LinkedList<Node> temp = new LinkedList<>(); temp.addAll(current.subList(0, seperateAT)); this.richClub.put(currentDegree, temp); currentRichClub.addAll(temp); LinkedList<Node> temp2 = new LinkedList<>(); temp2.addAll(current.subList(seperateAT, current.size())); if (!temp2.isEmpty()) this.nodesSortedByDegree.put(currentDegree, (LinkedList<Node>) temp2); break; } else { richClub.put(currentDegree, current); currentRichClub.addAll(current); } } for (Node n : currentRichClub) { DirectedNode ne = (DirectedNode) n; for (IElement iE : ne.getOutgoingEdges()) { DirectedEdge e = (DirectedEdge) iE; if (currentRichClub.contains(e.getDst())) { edgesBetweenRichClub++; } } } return true; }
private boolean applyAfterDirectedEdgeAddition(Update u) { DirectedEdge e = (DirectedEdge) ((EdgeUpdate) u).getEdge(); DirectedNode src = e.getSrc(); DirectedNode dst = e.getDst(); int srcDegree = src.getOutDegree(); int dstDegree = dst.getOutDegree(); if (richClub.containsKey(srcDegree - 1) && richClub.get(srcDegree - 1).contains(src)) { if (richClub.containsKey(dstDegree) && richClub.get(dstDegree).contains(dst)) { this.edgesBetweenRichClub++; } removeFromRichclub(src); addToRichClub(src); } else if (this.richClub.containsKey(srcDegree - 1) && this.nodesSortedByDegree.containsKey(srcDegree - 1) && this.nodesSortedByDegree.get(srcDegree - 1).contains(src)) { // changes for lastNode of Richclub DirectedNode lastNode = (DirectedNode) this.richClub.get(srcDegree - 1).removeLast(); if (this.richClub.get(lastNode.getOutDegree()).isEmpty()) { this.richClub.remove(lastNode.getOutDegree()); } addNodeToRest(lastNode); // Changes for src node for richclub this.nodesSortedByDegree.get(srcDegree - 1).remove(src); if (this.nodesSortedByDegree.get(src.getOutDegree() - 1).isEmpty()) { this.nodesSortedByDegree.remove(src.getOutDegree() - 1); } addToRichClub(src); // calculate changes for richclub connectivity for (IElement ie : src.getEdges()) { DirectedEdge edge = (DirectedEdge) ie; DirectedNode node = (DirectedNode) edge.getDifferingNode(src); if (this.richClub.containsKey(node.getOutDegree()) && this.richClub.get(node.getOutDegree()).contains(node)) { this.edgesBetweenRichClub++; } } for (IElement ie : lastNode.getEdges()) { DirectedEdge edge = (DirectedEdge) ie; DirectedNode node = (DirectedNode) edge.getDifferingNode(lastNode); if (this.richClub.containsKey(node.getOutDegree()) && this.richClub.get(node.getOutDegree()).contains(node)) { this.edgesBetweenRichClub--; } } } else { this.nodesSortedByDegree.get(src.getOutDegree() - 1).remove(src); if (this.nodesSortedByDegree.get(src.getOutDegree() - 1).isEmpty()) { this.nodesSortedByDegree.remove(src.getOutDegree() - 1); } addNodeToRest(src); } return true; }
private boolean applyAfterUpdateDirected(Update u) { if (u instanceof EdgeRemoval) { DirectedEdge e = (DirectedEdge) ((EdgeRemoval) u).getEdge(); DirectedNode a = e.getSrc(); DirectedNode b = e.getDst(); if (a.hasEdge(new DirectedEdge(b, a))) { // remove triangles for (IElement cUncasted : a.getNeighbors()) { DirectedNode c = (DirectedNode) cUncasted; if (b.hasNeighbor(c)) { this.removeTriangle(a); this.removeTriangle(b); this.removeTriangle(c); } } // remove potentials this.removePotentials(a, a.getNeighborCount()); this.removePotentials(b, b.getNeighborCount()); } } return true; }
private boolean applyBeforeUpdateDirected(Update u) { if (u instanceof NodeAddition) { Node n = (Node) ((NodeAddition) u).getNode(); this.localCC.setValue(n.getIndex(), 0); this.nodePotentialCount = ArrayUtils.set(this.nodePotentialCount, n.getIndex(), 0, Long.MIN_VALUE); this.nodeTriangleCount = ArrayUtils.set(this.nodeTriangleCount, n.getIndex(), 0, Long.MIN_VALUE); this.averageCC = ArrayUtils.avgIgnoreNaN(this.localCC.getValues()); } else if (u instanceof NodeRemoval) { DirectedNode n = (DirectedNode) ((NodeRemoval) u).getNode(); DirectedNode[] neighbors = new DirectedNode[n.getNeighborCount()]; int index = 0; for (IElement neighbor : n.getNeighbors()) { neighbors[index++] = (DirectedNode) neighbor; } for (int i = 0; i < neighbors.length; i++) { for (int j = i + 1; j < neighbors.length; j++) { if (neighbors[i].hasEdge(new DirectedEdge(neighbors[i], neighbors[j])) && neighbors[i].hasEdge(new DirectedEdge(neighbors[j], neighbors[i]))) { this.removeTriangle(n); this.removeTriangle(neighbors[i]); this.removeTriangle(neighbors[j]); } } this.removePotentials(neighbors[i], neighbors[i].getNeighborCount() - 1); } this.removePotentials(n, n.getNeighborCount() * (n.getNeighborCount() - 1) / 2); this.localCC.setValue(n.getIndex(), NodeValueList.emptyValue); this.nodePotentialCount[n.getIndex()] = Long.MIN_VALUE; this.nodeTriangleCount[n.getIndex()] = Long.MIN_VALUE; this.localCC.truncate(); this.nodePotentialCount = ArrayUtils.truncate(this.nodePotentialCount, Long.MIN_VALUE); this.nodeTriangleCount = ArrayUtils.truncate(this.nodeTriangleCount, Long.MIN_VALUE); this.averageCC = ArrayUtils.avgIgnoreNaN(this.localCC.getValues()); } else if (u instanceof EdgeAddition) { DirectedEdge e = (DirectedEdge) ((EdgeAddition) u).getEdge(); DirectedNode a = e.getSrc(); DirectedNode b = e.getDst(); if (a.hasEdge(new DirectedEdge(b, a))) { // new triangles for (IElement cUncasted : a.getNeighbors()) { DirectedNode c = (DirectedNode) cUncasted; if (b.hasNeighbor(c)) { this.addTriangle(a); this.addTriangle(b); this.addTriangle(c); } } // new potentials this.addPotentials(a, a.getNeighborCount()); this.addPotentials(b, b.getNeighborCount()); } } return true; }
private boolean applyAfterDirectedNodeRemoval(Update u) { DirectedNode node = (DirectedNode) ((NodeRemoval) u).getNode(); int min = Integer.MAX_VALUE; int max = 0; HashMap<Integer, LinkedList<DirectedNode>> order = new HashMap<>(); for (IElement ie : node.getIncomingEdges()) { DirectedEdge e = (DirectedEdge) ie; DirectedNode n = e.getSrc(); if (richClub.containsKey(n.getOutDegree() + 1) && richClub.get(n.getOutDegree() + 1).contains(n)) { this.edgesBetweenRichClub--; min = Math.min(min, n.getOutDegree()); max = Math.max(max, n.getOutDegree()); richClub.get(n.getOutDegree() + 1).remove(n); if (richClub.get(n.getOutDegree() + 1).isEmpty()) { richClub.remove(n.getOutDegree() + 1); } if (richClub.containsKey(n.getOutDegree())) { richClub.get(n.getOutDegree()).add(n); } else { richClub.put(n.getOutDegree(), new LinkedList<Node>()); richClub.get(n.getOutDegree()).add(n); } if (order.containsKey(n.getOutDegree())) { order.get(n.getOutDegree()).add(n); } else { order.put(n.getOutDegree(), new LinkedList<DirectedNode>()); order.get(n.getOutDegree()).add(n); } } else if (nodesSortedByDegree.containsKey(n.getOutDegree() + 1) && nodesSortedByDegree.get(n.getOutDegree() + 1).contains(n)) { nodesSortedByDegree.get(n.getOutDegree() + 1).remove(n); if (nodesSortedByDegree.get(n.getOutDegree() + 1).isEmpty()) { nodesSortedByDegree.remove(n.getOutDegree() + 1); } if (nodesSortedByDegree.containsKey(n.getOutDegree())) { nodesSortedByDegree.get(n.getOutDegree()).add(n); } else { nodesSortedByDegree.put(n.getOutDegree(), new LinkedList<Node>()); nodesSortedByDegree.get(n.getOutDegree()).add(n); } } else { System.out.println("f**k"); } } for (int i = min; i <= max; i++) { boolean f = false; if (f) { break; } if (!order.containsKey(i)) { continue; } for (DirectedNode n1 : order.get(i)) { int big = getBiggest(); if (i >= big) { f = true; break; } // changes for firstNode of Rest DirectedNode firstNode = (DirectedNode) this.nodesSortedByDegree.get(big).removeFirst(); if (this.nodesSortedByDegree.get(firstNode.getOutDegree()).isEmpty()) { this.nodesSortedByDegree.remove(firstNode.getOutDegree()); } addToRichClub(firstNode); // Changes for src node for richclub this.richClub.get(i).remove(n1); if (this.richClub.get(i).isEmpty()) { this.richClub.remove(i); } addNodeToRest(n1); // calculate changes for richclub connectivity for (IElement ie : n1.getEdges()) { DirectedEdge edge = (DirectedEdge) ie; DirectedNode n2 = (DirectedNode) edge.getDifferingNode(n1); if (this.richClub.containsKey(n2.getOutDegree()) && this.richClub.get(n2.getOutDegree()).contains(n2)) { this.edgesBetweenRichClub--; } } for (IElement ie : firstNode.getEdges()) { DirectedEdge edge = (DirectedEdge) ie; DirectedNode n2 = (DirectedNode) edge.getDifferingNode(firstNode); if (this.richClub.containsKey(n2.getOutDegree()) && this.richClub.get(n2.getOutDegree()).contains(n2)) { this.edgesBetweenRichClub++; } } } } if (this.richClub.containsKey(node.getOutDegree()) && this.richClub.get(node.getOutDegree()).contains(node)) { int degree = ((DirectedNode) node).getOutDegree(); // changes for firstNode of Rest DirectedNode firstNode = (DirectedNode) this.nodesSortedByDegree.get(getBiggest()).removeFirst(); if (this.nodesSortedByDegree.get(firstNode.getOutDegree()).isEmpty()) { this.nodesSortedByDegree.remove(firstNode.getOutDegree()); } addToRichClub(firstNode); // Changes for src node for richclub this.richClub.get(degree).remove(node); if (this.richClub.get(degree).isEmpty()) { this.richClub.remove(degree); } // calculate changes for richclub connectivity for (IElement ie : node.getOutgoingEdges()) { DirectedEdge edge = (DirectedEdge) ie; DirectedNode n2 = (DirectedNode) edge.getDifferingNode(node); if (this.richClub.containsKey(n2.getOutDegree()) && this.richClub.get(n2.getOutDegree()).contains(n2)) { this.edgesBetweenRichClub--; } } for (IElement ie : firstNode.getEdges()) { DirectedEdge edge = (DirectedEdge) ie; DirectedNode n2 = (DirectedNode) edge.getDifferingNode(firstNode); if (this.richClub.containsKey(n2.getOutDegree()) && this.richClub.get(n2.getOutDegree()).contains(n2)) { this.edgesBetweenRichClub++; } } } else { int degree = ((DirectedNode) node).getOutDegree(); this.nodesSortedByDegree.get(degree).remove(node); if (this.nodesSortedByDegree.get(degree).isEmpty()) { this.nodesSortedByDegree.remove(degree); } } return true; }
private void directedDelete(DirectedNode r, DirectedEdge e) { HashMap<Node, Node> parent = this.parents.get(r); HashMap<Node, Integer> height = this.heights.get(r); DirectedNode src = e.getSrc(); DirectedNode dst = e.getDst(); // if the source or dst or edge is not in tree do nothing if (height.get(src) == Integer.MAX_VALUE || height.get(dst) == Integer.MAX_VALUE || dst.equals(r) || !parent.get(dst).equals(src)) { return; } // Queues and data structure for tree change HashSet<DirectedNode> uncertain = new HashSet<DirectedNode>(); HashSet<DirectedNode> changed = new HashSet<DirectedNode>(); PriorityQueue<QueueElement<DirectedNode>> q = new PriorityQueue<QueueElement<DirectedNode>>(); q.add(new QueueElement<DirectedNode>(dst, height.get(dst))); uncertain.add(dst); parent.remove(dst); while (!q.isEmpty()) { QueueElement<DirectedNode> qE = q.poll(); DirectedNode w = qE.e; int key = qE.distance; // find the new shortest path int dist = Integer.MAX_VALUE; ArrayList<DirectedNode> minSettled = new ArrayList<DirectedNode>(); ArrayList<DirectedNode> min = new ArrayList<DirectedNode>(); for (IElement iEgde : w.getIncomingEdges()) { DirectedWeightedEdge edge = (DirectedWeightedEdge) iEgde; IntWeight eWeight = (IntWeight) edge.getWeight(); DirectedNode z = edge.getSrc(); if (changed.contains(z) || height.get(z) == Integer.MAX_VALUE) { continue; } if (height.get(z) + (int) eWeight.getWeight() < dist) { min.clear(); minSettled.clear(); min.add(z); if (!uncertain.contains(z)) minSettled.add(z); dist = height.get(z) + (int) eWeight.getWeight(); continue; } if (height.get(z) + (int) eWeight.getWeight() == dist) { min.add(z); if (!uncertain.contains(z)) minSettled.add(z); continue; } } boolean noPossibleNeighbour = (key >= breakLoop && dist > breakLoop) || (min.isEmpty() && (!uncertain.contains(w) || (key == dist))); // no neighbour found if (noPossibleNeighbour) { if (height.get(w) != Integer.MAX_VALUE) apsp.decr(height.get(w)); height.put(w, Integer.MAX_VALUE); parent.remove(w); continue; } if (uncertain.contains(w)) { if (key == dist) { if (minSettled.isEmpty()) { parent.put(w, min.get(0)); } else { parent.put(w, minSettled.get(0)); } if (height.get(w) != Integer.MAX_VALUE) apsp.decr(height.get(w)); apsp.incr(dist); height.put(w, dist); for (IElement iEgde : w.getOutgoingEdges()) { DirectedWeightedEdge edge = (DirectedWeightedEdge) iEgde; IntWeight iEdgeWeight = (IntWeight) edge.getWeight(); DirectedNode z = edge.getDst(); if (height.get(z) > dist + (int) iEdgeWeight.getWeight()) { q.remove(new QueueElement<DirectedNode>(z, dist + (int) iEdgeWeight.getWeight())); q.add(new QueueElement<DirectedNode>(z, dist + (int) iEdgeWeight.getWeight())); } } } else { changed.add(w); q.add(new QueueElement<DirectedNode>(w, dist)); uncertain.remove(w); for (IElement iEgde : w.getOutgoingEdges()) { DirectedEdge edge = (DirectedEdge) iEgde; DirectedNode z = edge.getDst(); if (parent.get(z) == w) { parent.remove(z); uncertain.add(z); q.add(new QueueElement<DirectedNode>(z, height.get(z))); } } } continue; } if (dist > key) { q.add(new QueueElement<DirectedNode>(w, dist)); continue; } if (minSettled.isEmpty()) { parent.put(w, min.get(0)); } else { parent.put(w, minSettled.get(0)); } changed.remove(w); if (height.get(w) != Integer.MAX_VALUE) apsp.decr(height.get(w)); apsp.incr(dist); height.put(w, dist); for (IElement iEgde : w.getOutgoingEdges()) { DirectedWeightedEdge edge = (DirectedWeightedEdge) iEgde; IntWeight eWeight = (IntWeight) edge.getWeight(); DirectedNode z = edge.getDst(); if (height.get(z) > dist + (int) eWeight.getWeight()) { q.remove(new QueueElement<DirectedNode>(z, dist + (int) eWeight.getWeight())); q.add(new QueueElement<DirectedNode>(z, dist + (int) eWeight.getWeight())); } } } }