@Override public void computeData(Graph g, Network n, HashMap<String, Metric> m) { Partition p = this.getPartition(g); this.largestComponent = p.getComponents()[0].length; this.largestComponentFraction = this.largestComponent / (double) g.getNodes().length; this.components = new double[p.getComponents().length]; this.componentsFraction = new double[p.getComponents().length]; for (int i = 0; i < p.getComponents().length; i++) { this.components[i] = p.getComponents()[i].length; this.componentsFraction[i] = this.components[i] / (double) g.getNodes().length; } }
@Override public Graph transform(Graph g) { System.err.println("This is not working completely yet, so don't expect good results!"); initIDSpace(g); /* * Phase 1 */ Node currentNode = null; List<Node> nodeList = Arrays.asList(g.getNodes()); List<Edge> removalList = new ArrayList<Edge>(); Collections.sort(nodeList, new NodeDegreeComparator()); for (int counter = 1; counter < (nodeList.size() - 3); counter++) { Boolean selectedANodeForThisIteration = false; if (currentNode != null) { // try to get a wave front / wave center node } if (!selectedANodeForThisIteration) { // We got no node yet - choose one with lowest degree currentNode = nodeList.get(0); } List<Edge> establishedEdges = getPairEdges(currentNode); } for (Node n : nodeList) System.out.println(n + " has degree " + n.getDegree()); // countAllCrossings(g); writeIDSpace(g); return g; }
@Override public void read(String filename, Graph graph) { Filereader fr = new Filereader(filename); // CLASS fr.readLine(); // KEY String key = fr.readLine(); // # MUDULUS this.modulus = Double.parseDouble(fr.readLine()); // # WRAP-AROUND this.wrapAround = Boolean.parseBoolean(fr.readLine()); // # PARTITIONS int partitions = Integer.parseInt(fr.readLine()); this.partitions = new RingPartition[partitions]; this.maxDistance = this.wrapAround ? this.modulus / 2.0 : this.modulus; // PARTITIONS String line = null; while ((line = fr.readLine()) != null) { String[] temp = line.split(":"); int index = Integer.parseInt(temp[0]); this.partitions[index] = new RingPartition(temp[1], this); } fr.close(); graph.addProperty(key, this); }
/** * returns the list of neighbors as candidates * * @param g Graph * @param n Current node * @return List of candidates */ @Override public List<Node> resolveCandidates(Graph g, Node n) { int[] nids = n.getOutgoingEdges(); ArrayList<Node> nn = new ArrayList<Node>(); for (int i : nids) { nn.add(g.getNode(i)); } return nn; }
@Override public void computeData(Graph g, Network n, HashMap<String, Metric> m) { this.runtime = new Timer(); int[] excludeFirst = this.getExcludeFirst(g.getNodes().length); this.isolatedComponentSizeAvg = new double[excludeFirst.length]; this.isolatedComponentSizeMax = new double[excludeFirst.length]; this.isolatedComponentSizeMed = new double[excludeFirst.length]; this.isolatedComponentSizeMin = new double[excludeFirst.length]; this.numberOfIsolatedComponents = new double[excludeFirst.length]; this.largestComponentSize = new double[excludeFirst.length]; this.largestComponentSizeFraction = new double[excludeFirst.length]; this.criticalPoint = 1.0; Random rand = new Random(); Node[] sorted = this.sorter.sort(g, rand); for (int i = 0; i < excludeFirst.length; i++) { boolean[] exclude = this.getExclude(sorted, excludeFirst[i]); Partition p = this.partition(g, sorted, exclude); this.numberOfIsolatedComponents[i] = p.getComponents().length - 1; this.largestComponentSize[i] = p.getLargestComponent().length; this.largestComponentSizeFraction[i] = (double) p.getLargestComponent().length / (double) g.getNodes().length; if (this.numberOfIsolatedComponents[i] == 0) { this.isolatedComponentSizeAvg[i] = 0; this.isolatedComponentSizeMax[i] = 0; this.isolatedComponentSizeMed[i] = 0; this.isolatedComponentSizeMin[i] = 0; } else { this.isolatedComponentSizeAvg[i] = this.avgIsolatedSize(p); this.isolatedComponentSizeMax[i] = p.getComponents()[p.getComponents().length - 2].length; this.isolatedComponentSizeMed[i] = p.getComponents()[(int) Math.floor(p.getComponents().length / 2)].length; this.isolatedComponentSizeMin[i] = p.getComponents()[p.getComponents().length - 1].length; } if (this.largestComponentSize[i] < 0.5 * (g.getNodes().length - excludeFirst[i]) && (double) excludeFirst[i] / (double) g.getNodes().length < this.criticalPoint) { this.criticalPoint = (double) excludeFirst[i] / (double) g.getNodes().length; } } this.runtime.end(); }
/* * (non-Javadoc) * * @see gtna.io.graphReader.GraphReader#read(java.lang.String) */ @Override public Graph read(String filename) { String sep1 = Config.get("SNAP_SEPARATOR_1"); String ffd = Config.get("FILESYSTEM_FOLDER_DELIMITER"); SNAPFileReader fr = new SNAPFileReader(filename); try { String line = null; String name = filename.substring(filename.lastIndexOf(ffd) + 1); Graph graph = new Graph(name); Map<Integer, Integer> idMapping = new HashMap<Integer, Integer>(); int nodecounter = 0; LinkedList<String> edges = new LinkedList<String>(); graphtype type = null; line = fr.readLine(); type = (line.contains("Directed graph")) ? graphtype.DIRECTED : graphtype.UNDIRECTED; while (!line.contains("FromNodeId") && !line.contains("ToNodeId")) { line = fr.readLine(); } nodecounter = parseEdges(sep1, fr, idMapping, nodecounter, edges, type); Node[] nodes = Node.init(idMapping.size(), graph); Edges e = new Edges(nodes, edges.size()); ListIterator<String> edgeIterator = edges.listIterator(); while (edgeIterator.hasNext()) { String[] pair = edgeIterator.next().split("-"); e.add(Integer.parseInt(pair[0]), Integer.parseInt(pair[1])); } e.fill(); graph.setNodes(nodes); return graph; } catch (Exception e) { return null; } finally { fr.close(); } }
@Override public Graph read(String filename) { String delimiter = Config.get("GRAPH_WRITER_DELIMITER"); Filereader fr = new Filereader(filename); String name = fr.readLine(); int N = Integer.parseInt(fr.readLine()); int E = Integer.parseInt(fr.readLine()); Graph graph = new Graph(name); Node[] nodes = Node.init(N, graph); Edges edges = new Edges(nodes, E); String line = null; while ((line = fr.readLine()) != null) { String[] temp = line.split(delimiter); edges.add(Integer.parseInt(temp[0]), Integer.parseInt(temp[1])); } edges.fill(); graph.setNodes(nodes); fr.close(); return graph; }
@Override public void computeData(Graph g, Network n, HashMap<String, Metric> m) { DataStorageList dsl = (DataStorageList) g.getProperty("DATA_STORAGE_0"); int max = 0; for (DataStorage ds : dsl.getList()) { // System.out.println("DS.size = " + ds.size()); if (ds.size() > max) { max = ds.size(); } } double[] distr = new double[max + 1]; for (DataStorage ds : dsl.getList()) { distr[ds.size()]++; } ArrayUtils.divide(distr, dsl.getList().length); this.dataItemsDistribution = new Distribution(distr); }
public static Graph read(String filename) throws Exception { Timer timer = new Timer(); RandomAccessFile file = new RandomAccessFile(new File(filename), "r"); // seek to names while (!file.readLine().startsWith("names/")) {} // read names Vector<WOTNode> wotNodes = new Vector<WOTNode>(); int index = 0; String line; while (!(line = file.readLine()).startsWith("keys/")) { if (!line.equals("")) { WOTNode node = new WOTNode(index, line); wotNodes.add(node); index += 1; } } // read keys for (index = 0; index < wotNodes.size(); index++) { byte[] key = new byte[4]; file.read(key); WOTNode node = wotNodes.get(index); node.key = Util.toInt(key); } // skip the "signatures/" line String signaturesLine = file.readLine(); if (!signaturesLine.startsWith("signatures/")) { // FIXME an IllegalArgumentException isn't really semantically // correct throw new IllegalArgumentException("A line starting with \"signatures/\" was expected."); } // read signatures for (index = 0; index < wotNodes.size(); index++) { WOTNode node = wotNodes.get(index); // read how many keys are signed by this key byte[] buffer = new byte[4]; file.read(buffer); int signatureCount = Util.toInt(buffer); // inspect all signatures for (int signatureIndex = 0; signatureIndex < signatureCount; signatureIndex++) { byte[] signatureBuffer = new byte[4]; file.read(signatureBuffer); int signature = Util.toInt(signatureBuffer); // get the signature type // TODO do something with the signature type // int signatureType = signature & SIGNATURE_TYPE_MASK; // get the target key int targetIndex = signature & SIGNATURE_INDEX_MASK; if (targetIndex >= wotNodes.size()) { // FIXME an IllegalArgumentException isn't really // semantically correct throw new IllegalArgumentException("A target index that matches a node was expected."); } // retrieve the target node WOTNode target = wotNodes.get(targetIndex); node.signatures.add(target); } } // skip the "debug/" line String debugLine = file.readLine(); if (!debugLine.startsWith("debug/")) { // FIXME an IllegalArgumentException isn't really semantically // correct throw new IllegalArgumentException("A line starting with \"debug/was expected."); } file.close(); timer.end(); // prepare return graph Graph graph = new Graph("WOT - read from " + filename); Node[] nodes = Node.init(wotNodes.size(), graph); Edges edges = new Edges(nodes, nodes.length); for (WOTNode source : wotNodes) { for (WOTNode target : source.signatures) { edges.add(source.index, target.index); } } edges.fill(); graph.setNodes(nodes); return graph; }
@Override public boolean applicable(Graph g, Network n, HashMap<String, Metric> m) { return g.hasProperty("DATA_STORAGE_0") && g.getProperty("DATA_STORAGE_0") instanceof DataStorageList; }