Merge branch 'release/v0.4'

KristofferC · KristofferC · commit 19c74cf2116d · 2015-02-06T10:03:57.000+01:00
diff --git a/.travis.yml b/.travis.yml
@@ -1,7 +1,7 @@
 language: julia
 julia:
     - release
-    - nightly
+    #- nightly
 notifications:
     email: false
 script:
diff --git a/README.md b/README.md
@@ -2,14 +2,14 @@
 
 Kd tree for Julia.
 
-[![Build Status](https://travis-ci.org/KristofferC/KDtree.jl.svg)](https://travis-ci.org/KristofferC/KDtree.jl) [![Coverage Status](https://coveralls.io/repos/KristofferC/KDtree.jl/badge.svg)](https://coveralls.io/r/KristofferC/KDtree.jl)
+[![Build Status](https://travis-ci.org/KristofferC/KDtree.jl.svg?branch=master)](https://travis-ci.org/KristofferC/KDtree.jl) [![Coverage Status](https://coveralls.io/repos/KristofferC/KDtree.jl/badge.svg)](https://coveralls.io/r/KristofferC/KDtree.jl)
 
 Currently supports KNN-search and finding all points inside an hyper sphere centered at a given point. Currently only
 uses Euclidean distance.
 
-Some care has been taken with regards to performance. For example the tree is not implemented as nodes pointing to other nodes but instead as an ensamble of densely packed arrays. This should give better cache locality. The negative aspect of this storage method is that the tree is immutable and new data can not be entered into the tree after it has been created.
+Some care has been taken with regards to performance. For example the tree is not implemented as nodes pointing to other nodes but instead as a collection of densely packed arrays. This should give better cache locality. The negative aspect of this storage method is that the tree is immutable and new data can not be entered into the tree after it has been created.
 
-There are some benchmarks for the creation of the tree and the different searches in the benchmark folder.
+There are some benchmarks for the creation of the tree and the different searches in the benchmark folder. 
 
 Since this is a new project there are still some obvious improvements which are listed in the TODO list.
 
@@ -64,11 +64,7 @@ gives both the indices and distances:
 ### TODOs
 * Implement a leaf size argument where the sub tree stop splitting after
    only a certain number of nodes are left in the sub tree.
-* Add proper benchmarks, compare with others implementations.
+* Add proper benchmarks, compare with others implementations. Update: Partly done
 * Add other measures than Euclidean distance.
-* Use a bounded priority queue for storing the K best points in KNN instead of a linear array (should only matter for large K).
-* Proper investigation of memory allocations and where time is spent.
-* Throw errors at dimension mismatch in the functions etc.
-
-
-
+* Use a bounded priority queue for storing the K best points in KNN instead of a linear array (should only matter for large K). 
+  Julias built in PQ is slower than a normal array
diff --git a/benchmark/bench_knn.jl b/benchmark/bench_knn.jl
@@ -3,10 +3,10 @@ using KDtree
 
 function run_bench_knn()
     dims = 3
-    n_points = [10^i for i in 3:5]
+    n_points = [10^i for i in 3:6]
     ks = [1, 3, 10, 50, 100, 500]
 
-    n_iters = 10
+    n_iters = 100
 
     times = fill(0.0, length(ks), length(n_points))
 
@@ -33,28 +33,11 @@ end
 run_bench_knn()
 
 #=
-2015-02-04 No bounds, type fixes
-[4.139509999999997e-6 6.266810000000003e-6 1.1824519999999996e-5 1.2813520000000002e-5
- 6.926150000000001e-6 8.745540000000002e-6 1.5848950000000007e-5 1.9322909999999995e-5
- 1.2340789999999995e-5 1.7301359999999997e-5 2.9695020000000008e-5 3.380342999999999e-5
- 3.891018e-5 5.718188999999997e-5 8.192254999999999e-5 0.00010137918999999997
- 6.649346000000001e-5 9.620713999999998e-5 0.00014474611999999997 0.00016459152000000002
- 0.0004432140299999998 0.0006229702799999999 0.0008457700199999998 0.0009439302800000001]
-
-
-2015-02-03: ArrayViews:
-[1.3996e-5 2.1771e-5 5.1316e-5 4.4474e-5
- 2.0837e-5 2.5502e-5 5.9402e-5 6.8732e-5
- 3.2034e-5 4.1364e-5 8.7393e-5 8.2106e-5
- 8.5838e-5 8.7394e-5 0.000183183 0.000170121
- 0.000156437 0.000143063 0.000305409 0.000290792
- 0.000695723 0.001162545 0.001638387 0.001731067]
-
-2015-02-02:
-[2.3015e-5 2.1771e-5 7.0288e-5 6.0958e-5
- 2.7368e-5 3.5143e-5 8.957e-5 7.7752e-5
- 6.0647e-5 5.0072e-5 0.000104499 0.000111029
- 0.000194691 0.000216772 0.000293591 0.000318472
- 0.000385027 0.000359835 0.000650316 0.000582517
- 0.003119404 0.005313561 0.006453713 0.006805152]
+2015-02-06 (removed old bench since they used a too volatile method)
+[2.54688e-6 7.427709999999996e-6 4.546329999999998e-6 4.439879999999999e-6
+ 3.1702599999999993e-6 3.8126800000000002e-6 5.36744e-6 1.047631e-5
+ 9.24091e-6 2.3145960000000002e-5 2.319162000000002e-5 2.1059090000000006e-5
+ 4.556972999999999e-5 5.366267e-5 6.215093000000004e-5 7.335329000000001e-5
+ 4.875141000000001e-5 5.9763709999999965e-5 0.00013036107000000003 0.00018395148999999993
+ 0.0007265081999999999 0.0011446717200000003 0.0012804762699999998 0.00121552762]
  =#
diff --git a/benchmark/bench_query_ball.jl b/benchmark/bench_query_ball.jl
@@ -9,7 +9,7 @@ function run_bench_query_ball()
     times = fill(0.0, length(rs), length(n_points))
 
     # Compile it
-    n_iters = 1000
+    n_iters = 2000
 
     tree = KDTree(randn(2,2))
     query_ball_point(tree, zeros(2), 0.1)
@@ -33,18 +33,9 @@ run_bench_query_ball()
 
 
 #=
-
-
-2015-02-03: ArrayViews + no sqrt
-[1.1196e-5 1.9593e-5 7.5885e-5
- 1.5239e-5 4.1986e-5 0.000167011
- 1.9905e-5 7.8374e-5 0.00041986
- 2.6125e-5 0.000124713 0.000603665]
-
-
-2015-02-03:
-[2.1149e-5 3.2966e-5 8.3661e-5
- 2.146e-5 5.1628e-5 0.000229523
- 2.7369e-5 0.000116005 0.000453138
- 4.012e-5 0.000204643 0.000789959]
+2015-02-06: (removed old inaccurate results)
+[6.202539999999983e-6 3.595097900000001e-5 0.00021109113900000007
+ 1.3630627000000005e-5 7.9238053e-5 0.0006688952190000003
+ 5.310767400000003e-5 0.0001541270569999998 0.001355720711000002
+ 3.338056700000001e-5 0.00026903708300000007 0.0022353193569999976]
  =#
diff --git a/src/kd_tree.jl b/src/kd_tree.jl
@@ -250,10 +250,6 @@ function _k_nearest_neighbour{T <: FloatingPoint}(tree::KDTree,
                                                   best_dists::Vector{T},
                                                   index::Int=1)
 
-    min_d, max_d = get_min_max_distance(tree.hyper_recs[index], point)
-    if min_d > best_dists[k]
-       return
-    end
     if is_leaf_node(tree, index)
         dist_d = euclidean_distance(get_point(tree, index), point)
         if dist_d <= best_dists[k] # Closer than the currently k closest.
@@ -272,15 +268,23 @@ function _k_nearest_neighbour{T <: FloatingPoint}(tree::KDTree,
         return
     end
 
-    dist_l = get_min_max_distance(tree.hyper_recs[get_left_node(index)], point)
-    dist_r = get_min_max_distance(tree.hyper_recs[get_right_node(index)], point)
-    if dist_l < dist_r
-        _k_nearest_neighbour(tree, point, k, best_idxs, best_dists, get_left_node(index))
-        _k_nearest_neighbour(tree, point, k, best_idxs, best_dists, get_right_node(index))
+    if point[tree.split_dims[index]] < tree.split_vals[index]
+        close = get_left_node(index)
+        far = get_right_node(index)
     else
-        _k_nearest_neighbour(tree, point, k, best_idxs, best_dists, get_right_node(index))
-        _k_nearest_neighbour(tree, point, k,best_idxs, best_dists,  get_left_node(index))     
+        far = get_left_node(index)
+        close = get_right_node(index)
     end
+    
+    _k_nearest_neighbour(tree, point, k, best_idxs, best_dists, close)
+        
+    # Only go far node if it sphere crosses hyperplane
+    if abs2(point[tree.split_dims[index]] - tree.split_vals[index]) < best_dists[k]
+         _k_nearest_neighbour(tree, point, k, best_idxs, best_dists, far)
+    end
+
+    return  
+
 end
 # Returns the indices for all points in the tree inside a
 # hypersphere of a given point with a given radius
@@ -370,5 +374,4 @@ function select_spec!{T <: FloatingPoint}(v::AbstractVector, k::Int, lo::Int,
         end
     end
     return
-end
-
+end
diff --git a/test/runtests.jl b/test/runtests.jl
@@ -1,12 +1,15 @@
 module TestKDtree
     using FactCheck
     using Base.Test
+    using Base.Collections
+
     using KDtree
 
-    FactCheck.onlystats(true)
+    #FactCheck.onlystats(true)
 
-    include("test_kd_tree.jl")
+    include("test_knn.jl")
+    include("test_query_ball.jl")
 
-    FactCheck.exitstatus()
+    #FactCheck.exitstatus()
 
 end #module
diff --git a/test/test_knn.jl b/test/test_knn.jl
@@ -0,0 +1,66 @@
+facts("KDtree") do
+
+    context("KDtree.nearest_neighbour") do
+
+        dim_data = 3
+        size_data = 1000
+        data = rand(dim_data, size_data)
+
+        tree = KDTree(data)
+
+        # Checking that we find existing points
+        for i = 1:50
+            n = rand(1:size_data)
+            idx, dist = k_nearest_neighbour(tree, data[:,n], 1)
+            @fact n => idx[1]
+            @fact KDtree.euclidean_distance(data[:,idx[1]], data[:, n]) => roughly(0.0)
+        end
+
+        # Check results vs brute force
+
+        pq = PriorityQueue{Int, Float64}(Base.Order.Reverse)
+
+        k = 3
+        for i in 1:k
+            enqueue!(pq, -i, Inf)
+        end
+
+        dim_data = 3
+        size_data = 500
+        data = rand(dim_data, size_data)
+        tree = KDTree(data)
+        p = rand(dim_data)
+
+        # Brute force
+        for n in 1:size_data
+            d = sqrt(KDtree.euclidean_distance(data[:,n], p))
+            if d <= peek(pq)[2] # Closer than the currently k closest.
+                dequeue!(pq)
+                enqueue!(pq, n, d)
+            end
+        end
+
+        idx, dist = k_nearest_neighbour(tree, p, k)
+
+        for i in 1:length(idx)
+            @fact idx[i] in keys(pq) => true
+        end
+
+       # 8 node rectangle
+        data = [0.0 0.0 0.0 0.5 0.5 1.0 1.0 1.0;
+                0.0 0.5 1.0 0.0 1.0 0.0 0.5 1.0]
+        tree = KDTree(data)
+
+        idxs, dists = k_nearest_neighbour(tree, [0.8, 0.8], 1)
+        @fact idxs[1] => 8 # Should be closest to top right corner
+        @fact sqrt(0.2^2 + 0.2^2) => roughly(dists[1])
+
+        idxs, dists = k_nearest_neighbour(tree, [0.1, 0.8], 3)
+        @fact idxs => [3, 2, 5]
+
+        @fact_throws k_nearest_neighbour(tree, [0.1, 0.8], 10) # k > n_points
+
+        @fact_throws k_nearest_neighbour(tree, [0.1], 10) # n_dim != trees dim
+    end  #context
+
+end # facts
diff --git a/test/test_query_ball.jl b/test/test_query_ball.jl
@@ -1,40 +1,5 @@
 facts("KDtree") do
 
-    context("KDtree.nearest_neighbour") do
-
-        dim_data = 3
-        size_data = 1000
-        data = randn(dim_data, size_data )
-
-        tree = KDTree(data)
-
-        # Checking that we find existing points
-        for i = 1:20
-            n = rand(1:size_data)
-            idx, dist = k_nearest_neighbour(tree, data[:,n], 1)
-            @fact n => idx[1]
-            @fact KDtree.euclidean_distance(data[:,idx[1]], data[:, n]) => roughly(0.0)
-        end
-
-
-
-       # 8 node rectangle
-        data = [0.0 0.0 0.0 0.5 0.5 1.0 1.0 1.0;
-                0.0 0.5 1.0 0.0 1.0 0.0 0.5 1.0]
-        tree = KDTree(data)
-
-        idxs, dists = k_nearest_neighbour(tree, [0.8, 0.8], 1)
-        @fact idxs[1] => 8 # Should be closest to top right corner
-        @fact sqrt(0.2^2 + 0.2^2) => roughly(dists[1])
-
-        idxs, dists = k_nearest_neighbour(tree, [0.1, 0.8], 3)
-        @fact idxs => [3, 2, 5]
-
-        @fact_throws k_nearest_neighbour(tree, [0.1, 0.8], 10) # k > n_points
-
-        @fact_throws k_nearest_neighbour(tree, [0.1], 10) # n_dim != trees dim
-    end  #context
-
     context("KDtree.ball_query") do
 
         data = [0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0;
@@ -56,8 +21,32 @@ facts("KDtree") do
         @fact idxs => [1, 2, 3, 4, 5, 6, 7, 8] #
 
         @fact_throws query_ball_poin(tree, [0.1], 1.0) # n_dim != trees dim
+
+
+        idx = Int[]
+        dim_data = 3
+        size_data = 100
+        data = rand(dim_data, size_data)
+        tree = KDTree(data)
+        p = zeros(dim_data)
+        r = 0.3
+        # Brute force
+        for n in 1:size_data
+            d = sqrt(KDtree.euclidean_distance([data[:,n]], p))
+            if d <= r # Closer than the currently k closest.
+                push!(idx, n)
+            end
+        end
+
+        q_idxs = query_ball_point(tree, p, r)
+
+        for i in 1:length(idx)
+            @fact q_idxs[i] in idx => true
+        end
+
     end #context
 
+    
     context("KDtree.yolo_testing") do
 
         # Tests that the n-points in a random hyper sphere around
@@ -82,4 +71,5 @@ facts("KDtree") do
             @fact idxs_ball[i] in idxs_knn => true
         end
     end #context
+    
 end # facts
