added poly helpers

Author: cvium

.idea/workspace.xml

@@ -25,7 +25,7 @@ public P findWinner(P first, P second) {
         double firstDistance = p.getDistance(first);
         double secondDistance = p.getDistance(second);
         if (Math.abs(firstDistance - secondDistance) < 1e-10) System.out.println("FUCK");
-        return firstDistance < secondDistance ? first : second;
+        return firstDistance <= secondDistance ? first : second;
     }
 
     @Override

src/main/java/tournament_tree/DistanceFunction.java

@@ -3,16 +3,12 @@
 import kds.solvers.EigenSolver;
 import org.ejml.data.Complex64F;
 import utils.Primitive;
-import utils.RootFinder;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.NoSuchElementException;
+import utils.Polynomial;
 
 /**
  * Created by clausvium on 22/12/16.
  */
-public class TournamentEvent<P extends Primitive> extends kds.Event<P>{
+public class TournamentEvent<P extends Primitive> extends kds.Event<P> {
 
     private TournamentNode<P> node;
     private TournamentTreeWinner<P> winnerFunction;
@@ -60,33 +56,28 @@ public void computeFailureTime(EigenSolver solver, double t) {
         double[] p2_coeffs = getDistCoeffs(winnerFunction.getP().getCoeffsX(), winnerFunction.getP().getCoeffsY(),
                 bCoeffsX, bCoeffsY);
 
-        double[] coeffs = new double[p1_coeffs.length];
-
-        for (int i = 0; i < p1_coeffs.length; ++i) {
-            coeffs[i] = p1_coeffs[i] - p2_coeffs[i];
-        }
+        double[] coeffs = Polynomial.subtract(p1_coeffs, p2_coeffs);
 
         try {
-            double failureTime = RootFinder.findFirstRoot(coeffs, t, this.inFailedEvent);
+            double failureTime = Polynomial.findFirstRoot(coeffs, t, this.inFailedEvent);
             super.setFailureTime(failureTime);
-        } catch (RootFinder.NoRootException ex) {
+        } catch (Polynomial.NoRootException ex) {
             // event is invalid
             this.setValid(false);
             super.setFailureTime(-1);
         }
     }
 
     double[] getDistCoeffs(double[] p1_coeffsX, double[] p1_coeffsY, double[] p2_coeffsX, double[] p2_coeffsY) {
-        double[] x = expand(p1_coeffsX, p2_coeffsX);
-        double[] y = expand(p1_coeffsY, p2_coeffsY);
 
-        double[] res = new double[x.length];
+        // dist^2 = (p2_x - p1_x)^2 + (p2_y - p1_y)^2
+        double[] x = Polynomial.subtract(p1_coeffsX, p2_coeffsX);
+        double[] y = Polynomial.subtract(p1_coeffsY, p2_coeffsY);
 
-        for (int i = 0; i < x.length; ++i) {
-            res[i] = x[i] + y[i];
-        }
+        double[] x_squared = Polynomial.multiplication(x, x);
+        double[] y_squared = Polynomial.multiplication(y, y);
 
-        return res;
+        return Polynomial.add(x_squared, y_squared);
     }
 
     double[] expand(double[] p1_coeffs, double[] p2_coeffs) {

src/main/java/tournament_tree/TournamentEvent.java

@@ -301,9 +301,10 @@ private void rebalance(double t, TournamentNode<P> tmp_node) {
                     rotate_right(t, tmp_node.getRightChild());
                     rotate_left(t, tmp_node.getLeftChild());
                 }
+            } else {
+                // even if we don't rotate, we have to update the winner certificate
+                updateWinner(t, tmp_node);
             }
-            // even if we don't rotate, we have to update the winner certificate
-            updateWinner(t, tmp_node);
 
             tmp_node = tmp_node.getParent();
         }
@@ -374,7 +375,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
         updateWinner(t, node);
-        //updateWinner(t, newRoot);
+        updateWinner(t, newRoot);
     }
 
     public void rotate_right(double t, TournamentNode<P> node) {

src/main/java/tournament_tree/TournamentTree.java

@@ -20,7 +20,7 @@ public static void main(String[] args) throws Exception {
         ArrayList<KDSPoint> leaves = new ArrayList<>();
         Random rand = new Random();
 
-        for (int i = 0; i < 10; ++i) {
+        for (int i = 0; i < 2; ++i) {
             double[] coeffsX = new double[2];
             double[] coeffsY = new double[2];
             for (int j = 0; j < 2; ++j) {

src/main/java/tournament_tree/run.java

@@ -0,0 +1,95 @@
+package utils;
+
+import kds.solvers.EigenSolver;
+import org.ejml.data.Complex64F;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.NoSuchElementException;
+
+/**
+ * Created by clausvium on 02/01/17.
+ */
+public class Polynomial {
+
+    public static class NoRootException extends Exception {
+
+    }
+
+    public static double findFirstRoot(double[] coeffs, double t, boolean inFailedEvent) throws NoRootException {
+        if (coeffs.length == 0) throw new NoRootException();
+
+        EigenSolver solver = new EigenSolver();
+        Complex64F[] rootsX = solver.findRoots(coeffs, t);
+
+        ArrayList<Double> rootsXR = new ArrayList<>();
+
+        for (Complex64F r : rootsX) {
+            if (Math.abs(r.getImaginary()) < 1e-10 && r.getReal() >= t) {
+                rootsXR.add(Math.abs(r.getReal()));
+            }
+        }
+
+        if (inFailedEvent) {
+            Collections.sort(rootsXR);
+
+            for (double r : rootsXR) {
+                if (r-t > 1e-10) {
+                    return r;
+                }
+            }
+        } else {
+            try {
+                return Collections.min(rootsXR);
+            } catch (NoSuchElementException e) {
+                // do nothing
+            }
+        }
+
+        throw new NoRootException();
+    }
+
+    public static double[] multiplication(double[] p1, double[] p2) {
+        int totalLength = p1.length + p2.length - 1;
+        double[] result = new double[totalLength];
+        for (int i = 0; i < p1.length; i++) {
+            for (int j = 0; j < p2.length; j++) {
+                result[i + j] += p1[i] * p2[j];
+            }
+        }
+
+        return result;
+    }
+
+    public static double[] subtract(double[] p1, double[] p2) {
+        int max_length = p1.length < p2.length ? p2.length : p1.length;
+        double[] result = new double[max_length];
+
+        for (int i = 0; i < max_length; ++i) {
+            if (i >= p1.length)
+                result[i] = p2[i];
+            else if (i >= p2.length)
+                result[i] = -p1[i];
+            else
+                result[i] = p2[i] - p1[i];
+        }
+
+        return result;
+    }
+
+    public static double[] add(double[] p1, double[] p2) {
+        int max_length = p1.length < p2.length ? p2.length : p1.length;
+        double[] result = new double[max_length];
+
+        for (int i = 0; i < max_length; ++i) {
+            if (i >= p1.length)
+                result[i] = p2[i];
+            else if (i >= p2.length)
+                result[i] = p1[i];
+            else
+                result[i] = p2[i] + p1[i];
+        }
+
+        return result;
+    }
+}