Updated readme

Author: tdebatty

README.md

@@ -51,41 +51,40 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Random;
 
-
 public class NNDescentExample {
 
     public static void main(String[] args) {
         Random r = new Random();
         int count = 1000;
         int k = 10;
-        
-        // 1. Create the nodes
-        ArrayList<Node> nodes = new ArrayList<Node>(count);
+
+        // Create the nodes
+        ArrayList<Integer> nodes = new ArrayList<Integer>(count);
         for (int i = 0; i < count; i++) {
             // The value of our nodes will be an int
-            nodes.add(new Node<Integer>(String.valueOf(i), r.nextInt(10 * count)));
+            nodes.add(r.nextInt(10 * count));
         }
-        
-        // 2. Instantiate and configure the build algorithm
+
+        // Instantiate and configure the build algorithm
         NNDescent builder = new NNDescent();
         builder.setK(k);
-        
+
         // early termination coefficient
         builder.setDelta(0.1);
-        
+
         // sampling coefficient
         builder.setRho(0.2);
-        
+
         builder.setMaxIterations(10);
-        
+
         builder.setSimilarity(new SimilarityInterface<Integer>() {
 
             @Override
             public double similarity(Integer v1, Integer v2) {
                 return 1.0 / (1.0 + Math.abs(v1 - v2));
             }
         });
-        
+
         // Optionnallly, define a callback to get some feedback...
         builder.setCallback(new CallbackInterface() {
 
@@ -94,58 +93,56 @@ public class NNDescentExample {
                 System.out.println(data);
             }
         });
-        
-        // 3. Run the algorithm and get computed graph
+
+        // Run the algorithm and get computed graph
         Graph<Integer> graph = builder.computeGraph(nodes);
-        
+
         // Display neighborlists
-        for (Node n : nodes) {
-            NeighborList nl = graph.get(n);
+        for (Integer n : nodes) {
+            NeighborList nl = graph.getNeighbors(n);
             System.out.print(n);
             System.out.println(nl);
         }
-        
+
         // Optionnally, we can test the builder
         // This will compute the approximate graph, and then the exact graph
         // and compare results...
         builder.test(nodes);
-        
-        // 4. Analyze the graph:
+
+        // Analyze the graph:
         // Count number of connected components
         System.out.println(graph.connectedComponents().size());
-        
+
         // Search a query (fast approximative algorithm)
-        System.out.println(graph.search(r.nextInt(10 * count), 1));
-        
+        System.out.println(graph.fastSearch(r.nextInt(10 * count), 1));
+
         // Count number of strongly connected components
         System.out.println(graph.stronglyConnectedComponents().size());
-        
-        // Convert the graph to an online graph (to which we can add new nodes)
-        OnlineGraph<Integer> online_graph = new OnlineGraph<Integer>(graph);
-        
+
         // Now we can add a node to the graph (using a fast approximate algorithm)
-        online_graph.addNode(
-                new Node<Integer>("my new node 1", r.nextInt(10 * count)));
+        graph.fastAdd(r.nextInt(10 * count));
     }
 }
 ```
 
 This will produce something like:
 
 ```
-{computed_similarities=64361, c=4542, iterations=6, computed_similarities_ratio=0.12885085085085085}
-{computed_similarities=75008, c=4031, iterations=7, computed_similarities_ratio=0.15016616616616615}
-{computed_similarities=86254, c=3201, iterations=8, computed_similarities_ratio=0.17268068068068068}
-{computed_similarities=97291, c=2302, iterations=9, computed_similarities_ratio=0.19477677677677677}
-{computed_similarities=108458, c=1634, iterations=10, computed_similarities_ratio=0.21713313313313312}
+...
+{computed_similarities=58141, computed_similarities_ratio=0.1163983983983984, c=4426, iterations=5}
+{computed_similarities=69126, computed_similarities_ratio=0.1383903903903904, c=3962, iterations=6}
+{computed_similarities=80369, computed_similarities_ratio=0.1608988988988989, c=3575, iterations=7}
+{computed_similarities=91560, computed_similarities_ratio=0.1833033033033033, c=2777, iterations=8}
+{computed_similarities=102698, computed_similarities_ratio=0.2056016016016016, c=2074, iterations=9}
+{computed_similarities=114014, computed_similarities_ratio=0.22825625625625626, c=1317, iterations=10}
 Theoretical speedup: 1.0
-Computed similarities: 108458
-Speedup ratio: 4.605469398292427
-Correct edges: 8180 (81.8%)
-Quality-equivalent speedup: 3.767273967803205
-6
-[(523,9520,0.08333333333333333)]
-12
+Computed similarities: 114014
+Speedup ratio: 4.381040924798709
+Correct edges: 8220 (82.19999999999999%)
+Quality-equivalent speedup: 3.6012156401845385
+14
+[(6181,0.06666666666666667)]
+26
 
 ```