tournament tree hype!

cvium · cvium · commit fba8f5af74b9 · 2017-01-28T13:24:40.000+01:00
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
diff --git a/src/main/java/kds/Simulator.java b/src/main/java/kds/Simulator.java
@@ -114,8 +114,8 @@ public int run(boolean visualize, boolean auditEveryTimestep) throws IOException
                     for (EventType e : es) {
                         if (e.isValid()) {
                             event = true;
-                            kds.process(e);
                             LOGGER.log(Level.FINER, "EVENT at time t={0}", e.getFailureTime());
+                            kds.process(e);
                         }
                     }
                 }
diff --git a/src/main/java/tournament_tree/DistanceFunction.java b/src/main/java/tournament_tree/DistanceFunction.java
@@ -21,7 +21,10 @@ public void setP(P p) {
     }
 
     @Override
-    public P findWinner(P first, P second) {
+    public P findWinner(double t, P first, P second) {
+        p.updatePosition(t);
+        first.updatePosition(t);
+        second.updatePosition(t);
         double firstDistance = p.getDistance(first);
         double secondDistance = p.getDistance(second);
         if (Math.abs(firstDistance - secondDistance) < 1e-10) System.out.println("FUCK");
@@ -31,6 +34,7 @@ public P findWinner(P first, P second) {
     @Override
     public double computeValue(double t, Primitive primitive) {
         p.updatePosition(t);
+        primitive.updatePosition(t);
         return p.getDistance(primitive);
     }
 }
diff --git a/src/main/java/tournament_tree/TournamentEvent.java b/src/main/java/tournament_tree/TournamentEvent.java
@@ -58,7 +58,7 @@ public void computeFailureTime(EigenSolver solver, double t) {
         double[] p2_coeffs = getDistCoeffs(winnerFunction.getP().getCoeffsX(), winnerFunction.getP().getCoeffsY(),
                 bCoeffsX, bCoeffsY);
 
-        double[] coeffs = Polynomial.subtract(p2_coeffs, p1_coeffs);
+        double[] coeffs = Polynomial.subtract(p1_coeffs, p2_coeffs);
 
         try {
             double failureTime = Polynomial.findFirstRoot(coeffs, t, this.inFailedEvent);
diff --git a/src/main/java/tournament_tree/TournamentTree.java b/src/main/java/tournament_tree/TournamentTree.java
@@ -44,7 +44,6 @@ public TournamentTree(double t, ArrayList<P> leaves, TournamentTreeWinner<P> win
     public boolean audit(double t) {
         ArrayList<Double> distances = new ArrayList<>();
         for (TournamentNode<P> leaf : leaves) {
-            leaf.getWinner().updatePosition(t);
             distances.add(winnerFunction.computeValue(t, leaf.getWinner()));
         }
         Collections.sort(distances);
@@ -59,6 +58,10 @@ public boolean audit(double t) {
             valid = false;
             LOGGER.info("The tree itself is not valid :(");
         }
+        if (!root.getParent().isNull()) {
+            valid = false;
+            LOGGER.info("The root is not the root :(");
+        }
         return valid;
     }
 
@@ -72,10 +75,10 @@ public boolean validate(TournamentNode<P> node) {
         if (!valid) return false; // no need to check, TODO print out offenders
 
         if (!node.getLeftChild().isNull()) {
-            valid = node.getLeftChild().getKey() < node.getKey() && isBalanced(node.getLeftChild(), node);
+            valid = node.getLeftChild().getKey() <= node.getKey() && isBalanced(node.getLeftChild(), node);
         }
         if (!node.getRightChild().isNull()) {
-            valid = valid && node.getKey() <= node.getRightChild().getKey() && isBalanced(node.getRightChild(), node);
+            valid = valid && node.getKey() < node.getRightChild().getKey() && isBalanced(node.getRightChild(), node);
         }
         return valid;
     }
@@ -105,7 +108,7 @@ public void process(TournamentEvent<P> event) {
             event.getNode().setWinner(event.getNode().getLeftChild().getWinner());
         }
 
-        event.getNode().createEvent(solver, event.getFailureTime(), winnerFunction, true);
+        eq.add(event.getNode().createEvent(solver, event.getFailureTime(), winnerFunction, true));
 
         // percolate
         updateWinners(event.getFailureTime(), event.getNode().getParent());
@@ -143,17 +146,17 @@ public void setWinner(TournamentNode<P> winner) {
     public TournamentNode<P> insert(double t, int key, P winner) {
         if (root == null) {
             root = new TournamentNode<>(key, winner);
-            root.setRightChild(new TournamentNode<>(key, winner));
+            root.setLeftChild(new TournamentNode<>(key, winner));
             return root;
         }
 
         // else -- NOTE: I do not use a stack to keep track of the traversed path. It can be done by keeping a parent
         //               pointer in every node. Requires more space (obviously), but it makes the code nicer imo.
         TournamentNode<P> leaf = root;
 
-        // find the location to insert, which is always a leaf
+        // find the location to insert
         while (!leaf.isNull()) {
-            if (key < leaf.getKey()) leaf = leaf.getLeftChild();
+            if (key <= leaf.getKey()) leaf = leaf.getLeftChild();
             else leaf = leaf.getRightChild();
         }
 
@@ -167,22 +170,23 @@ public TournamentNode<P> insert(double t, int key, P winner) {
         TournamentNode<P> new_node = new TournamentNode<>(key, winner);
         // attach the new node to the leaf node and alter the old leaf node such that it becomes an internal node
         // which means the old leaf must be moved down a level and become the new leaf's sibling
-        if (key < leaf.getKey()) {
-            // a leaf must always be a right child!
-            TournamentNode<P> new_inner = new TournamentNode<>(key, winner);
-            new_inner.setRightChild(new_node);
-            leaf.setLeftChild(new_inner);
-            leaf.setRightChild(new TournamentNode<>(leaf.getKey(), leaf.getWinner()));
+        // that is if it's even a leaf, no guarantee
+        if (key <= leaf.getKey()) {
+            if (leaf.isLeaf()) {
+                // have to create a new inner node since a leaf cannot have any children
+                TournamentNode<P> new_leaf = new TournamentNode<>(leaf.getKey(), leaf.getWinner());
+                leaf.setKey(key);  // have to replace its key since
+                leaf.setRightChild(new_leaf);
+            }
+            leaf.setLeftChild(new_node);
         }
         else  {
-            // here we have to swap the keys as we always let inner nodes have the key of its right leaf
-            // it is safe to do as everything in the left subtree is less than the new key
+            if (leaf.isLeaf()) {
+                // have to create a new inner node since a leaf cannot have any children
+                TournamentNode<P> new_leaf = new TournamentNode<>(leaf.getKey(), leaf.getWinner());
+                leaf.setLeftChild(new_leaf);
+            }
             leaf.setRightChild(new_node);
-            // a leaf must always be a right child!
-            TournamentNode<P> new_inner = new TournamentNode<>(leaf.getKey(), leaf.getWinner());
-            new_inner.setRightChild(new TournamentNode<>(leaf.getKey(), leaf.getWinner()));
-            leaf.setLeftChild(new_inner);
-            leaf.setKey(new_node.getKey());
         }
         // time to rebalance the tree
         rebalance(t, leaf);
@@ -233,7 +237,7 @@ private void updateWinner(double t, TournamentNode<P> node) {
             P leftWinner = node.getLeftChild().getWinner();
             P rightWinner = node.getRightChild().getWinner();
 
-            node.setWinner(winnerFunction.findWinner(leftWinner, rightWinner));
+            node.setWinner(winnerFunction.findWinner(t, leftWinner, rightWinner));
         }
 
         if (node.getEvent() != null) eq.remove(node.getEvent());
@@ -246,7 +250,7 @@ public TournamentNode<P> delete(double t, int key) {
 
         if (node == null) return null;
 
-        // should be safe to assume that the doubles match, otherwise I suck
+        // should be safe to assume that the keys match, otherwise I suck
         assert node.getKey() == key;
 
         return delete(t, node);
@@ -318,7 +322,9 @@ private void rebalance(double t, TournamentNode<P> tmp_node) {
                     rotate_right(t, tmp_node.getRightChild());
                     rotate_left(t, tmp_node.getLeftChild());
                 }
-            } else if (!tmp_node.isLeaf()) {
+            }
+
+            if (!tmp_node.isLeaf()) {
                 // even if we don't rotate, we have to update the winner certificate
                 updateWinner(t, tmp_node);
             }
@@ -340,8 +346,8 @@ public TournamentNode<P> find(double key) {
         else tmp_node = root;
 
         while (!tmp_node.isNull()) {
-            if (key < tmp_node.getKey()) tmp_node = tmp_node.getLeftChild();
-            else if (key >= tmp_node.getKey()) tmp_node = tmp_node.getRightChild();
+            if (key <= tmp_node.getKey()) tmp_node = tmp_node.getLeftChild();
+            else if (key > tmp_node.getKey()) tmp_node = tmp_node.getRightChild();
             else break;
         }
 
@@ -383,7 +389,7 @@ public void rotate_left(double t, TournamentNode<P> node) {
             // reset its parent to avoid a weird cycle
             newRoot.setParent(null);
             // update root
-            root = newRoot;
+            this.root = newRoot;
         }
         newRoot.setLeftChild(node);
         // update b's weights and then a's
@@ -392,7 +398,7 @@ public void rotate_left(double t, TournamentNode<P> node) {
 
         // update the winners, we don't let it percolate though as there may be more rotations
         if (!node.isLeaf()) updateWinner(t, node);
-        //updateWinner(t, newRoot);
+        updateWinner(t, newRoot);
     }
 
     public void rotate_right(double t, TournamentNode<P> node) {
@@ -437,7 +443,7 @@ public void rotate_right(double t, TournamentNode<P> node) {
             // this means that 'node' is the root and since 'newRoot' is a child of 'node', we have to manually
             // reset its parent to avoid a weird cycle
             newRoot.setParent(null);
-            root = newRoot;
+            this.root = newRoot;
         }
         newRoot.setRightChild(node);
         // process a's weights and then b's
@@ -446,7 +452,7 @@ public void rotate_right(double t, TournamentNode<P> node) {
 
         // process the winners, we don't let it percolate though as there may be more rotations
         if (!node.isLeaf()) updateWinner(t, node);
-        //updateWinner(t, newRoot);
+        updateWinner(t, newRoot);
     }
 
     public TournamentNode<P> predecessor(TournamentNode<P> node) {
diff --git a/src/main/java/tournament_tree/TournamentTreeWinner.java b/src/main/java/tournament_tree/TournamentTreeWinner.java
@@ -6,7 +6,7 @@
  * Created by clausvium on 28/12/16.
  */
 public interface TournamentTreeWinner<P extends Primitive> {
-    P findWinner(P first, P second);
+    P findWinner(double t, P first, P second);
     double computeValue(double t, P p);
     P getP();
 }
diff --git a/src/main/java/tournament_tree/run.java b/src/main/java/tournament_tree/run.java
@@ -18,18 +18,19 @@ public class run {
     public static void main(String[] args) throws Exception {
         int failedRuns = 0;
         int numRuns = 1000;
+        int numCoeffs = 10;
         for (int run = 0; run < numRuns; ++run) {
             Random rand = new Random();
 
-            KDSPoint p = new KDSPoint(new double[]{0.1, 1.1},
-                    new double[]{0.3, 2.1});
+            KDSPoint p = new KDSPoint(new double[]{0.1, 0.2, 0.4},
+                    new double[]{0.3, 2, 0.7});
             DistanceFunction<KDSPoint> distanceFunction = new DistanceFunction<>(p);
             ArrayList<KDSPoint> leaves = new ArrayList<>();
 
             for (int i = 0; i < 100; ++i) {
-                double[] coeffsX = new double[2];
-                double[] coeffsY = new double[2];
-                for (int j = 0; j < 2; ++j) {
+                double[] coeffsX = new double[numCoeffs];
+                double[] coeffsY = new double[numCoeffs];
+                for (int j = 0; j < numCoeffs; ++j) {
                     coeffsX[j] = 1 + (1 + 1) * rand.nextDouble();//
                     coeffsY[j] = -1 + (1 + 1) * rand.nextDouble();
                 }
@@ -41,7 +42,7 @@ public static void main(String[] args) throws Exception {
             Simulator<KDSPoint, TournamentEvent<KDSPoint>> simulator = new Simulator<>(tournamentTree, 0, 0.1, 10, Level.ALL);
             //simulator.setScene(J2DScene.createJ2DSceneInFrame());
             //p.draw(simulator.getScene(), 0);
-            int error = simulator.run(false, false);
+            int error = simulator.run(false, true);
             if (error != 0) {
                 ++failedRuns;
             }

Original file line number	Diff line number	Diff line change
`@@ -114,8 +114,8 @@ public int run(boolean visualize, boolean auditEveryTimestep) throws IOException`
`114`	`114`	`for (EventType e : es) {`
`115`	`115`	`if (e.isValid()) {`
`116`	`116`	`event = true;`
`117`		`- kds.process(e);`
`118`	`117`	`LOGGER.log(Level.FINER, "EVENT at time t={0}", e.getFailureTime());`
	`118`	`+ kds.process(e);`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,10 @@ public void setP(P p) {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`@Override`
`24`		`- public P findWinner(P first, P second) {`
	`24`	`+ public P findWinner(double t, P first, P second) {`
	`25`	`+ p.updatePosition(t);`
	`26`	`+ first.updatePosition(t);`
	`27`	`+ second.updatePosition(t);`
`25`	`28`	`double firstDistance = p.getDistance(first);`
`26`	`29`	`double secondDistance = p.getDistance(second);`
`27`	`30`	`if (Math.abs(firstDistance - secondDistance) < 1e-10) System.out.println("FUCK");`
`@@ -31,6 +34,7 @@ public P findWinner(P first, P second) {`
`31`	`34`	`@Override`
`32`	`35`	`public double computeValue(double t, Primitive primitive) {`
`33`	`36`	`p.updatePosition(t);`
	`37`	`+ primitive.updatePosition(t);`
`34`	`38`	`return p.getDistance(primitive);`
`35`	`39`	`}`
`36`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`* Created by clausvium on 28/12/16.`
`7`	`7`	`*/`
`8`	`8`	`public interface TournamentTreeWinner<P extends Primitive> {`
`9`		`- P findWinner(P first, P second);`
	`9`	`+ P findWinner(double t, P first, P second);`
`10`	`10`	`double computeValue(double t, P p);`
`11`	`11`	`P getP();`
`12`	`12`	`}`