Fold sorted vector into knn search and remove incomplete priority queue implementation

Author: cloudkj

README.md

@@ -36,7 +36,6 @@ Add the following dependency to your project:
 
 * [Binary tree](https://cloudkj.github.io/lambda-ml/lambda-ml.data.binary-tree.html)
 * [K-d tree](https://cloudkj.github.io/lambda-ml/lambda-ml.data.kd-tree.html)
-* [Priority queue](https://cloudkj.github.io/lambda-ml/lambda-ml.data.priority-queue.html)
 
 ## Examples
 

src/lambda_ml/data/priority_queue.clj

@@ -12,8 +12,46 @@
   ```"
   (:require [lambda-ml.core :refer :all]
             [lambda-ml.data.binary-tree :as bt]
-            [lambda-ml.data.kd-tree :as kd]
-            [lambda-ml.data.priority-queue :as pq]))
+            [lambda-ml.data.kd-tree :as kd]))
+
+(defn make-item
+  [value priority]
+  (vector priority value))
+
+(defn item-priority
+  [item]
+  (nth item 0))
+
+(defn item-value
+  [item]
+  (nth item 1))
+
+(defn insert
+  [v value priority bound]
+  (let [full (>= (count v) bound)]
+    (cond
+      ;; Empty vector
+      (empty? v)
+      (vector (make-item value priority))
+      ;; Full vector and item priority is too high
+      (and full (>= priority (item-priority (peek v))))
+      v
+      :else
+      ;; Find position and insert item
+      (let [index (loop [lo 0
+                         hi (count v)]
+                    (if (>= lo hi)
+                      lo
+                      (let [mid (quot (+ lo hi) 2)]
+                        (if (< priority (item-priority (nth v mid)))
+                          (recur lo mid)
+                          (recur (+ mid 1) hi)))))
+            item (make-item value priority)
+            end (if full (dec (count v)) (count v))]
+        (apply conj
+               (subvec v 0 index)
+               item
+               (subvec v index end))))))
 
 (defn make-nearest-neighbor-search
   "Given a distance function f and a coll of items, each of which have an
@@ -29,7 +67,7 @@
         t (kd/make-tree dims items g)]
     (fn knn
       ([k query]
-       (knn k query t 0 (pq/make-queue)))
+       (knn k query t 0 (vector)))
       ([k query tree depth cand]
        (if (nil? tree)
          cand
@@ -41,13 +79,13 @@
                [near far] (if (<= (nth query-point dim) (nth node-point dim)) [left right] [right left])
                cand (->>
                      ;; Try to add current node to candidates
-                     (pq/insert cand node (f query-point node-point) k)
+                     (insert cand node (f query-point node-point) k)
                      ;; Explore near branch
                      (knn k query near (inc depth)))]
            ;; Optionally, explore far branch
            (if (or (< (count cand) k)
                    (< (f query-point node-point dim)
-                      (pq/item-priority (pq/get-tail cand))))
+                      (item-priority (peek cand))))
              (knn k query far (inc depth) cand)
              cand))))))))
 
@@ -67,7 +105,7 @@
       ;; values in last position in training data examples
       (->> (map #(conj (vec %) nil) x)
            (map #(lookup k %))
-           (map #(map (comp last pq/item-value) %))
+           (map #(map (comp last item-value) %))
            (map agg)))))
 
 (defn make-nearest-neighbors-classifier

src/lambda_ml/nearest_neighbors.clj

@@ -2,22 +2,21 @@
   (:require [clojure.test :refer :all]
             [clojure.set :refer :all]
             [lambda-ml.nearest-neighbors :refer :all]
-            [lambda-ml.distance :as d]
-            [lambda-ml.data.priority-queue :as pq]))
+            [lambda-ml.distance :as d]))
 
 (deftest test-nearest-neighbor-search
   (let [search (make-nearest-neighbor-search d/euclidean [[2 3] [5 4] [9 6] [4 7] [8 1] [7 2]])]
-    (is (= [7 2] (pq/item-value (second (search 2 [8 1])))))
-    (is (= [5 4] (pq/item-value (second (search 2 [2 3])))))
-    (is (= [8 1] (pq/item-value (second (search 2 [7 2])))))
-    (is (= [5 4] (pq/item-value (second (search 2 [4 7])))))
+    (is (= [7 2] (item-value (second (search 2 [8 1])))))
+    (is (= [5 4] (item-value (second (search 2 [2 3])))))
+    (is (= [8 1] (item-value (second (search 2 [7 2])))))
+    (is (= [5 4] (item-value (second (search 2 [4 7])))))
     (is (= 3 (count (search 3 [2 3]))))
     (is (= 6 (count (search 6 [2 3]))))
     (is (= 6 (count (search 9 [2 3]))))))
 
 (deftest test-nearest-neighbor-search2
   (let [search (make-nearest-neighbor-search d/euclidean [[1 11] [2 5] [4 8] [6 4] [5 0] [7 9] [8 2]])]
-    (is (= [4 8] (pq/item-value (first (search 5 [3 9])))))))
+    (is (= [4 8] (item-value (first (search 5 [3 9])))))))
 
 (deftest test-nearest-neighbor-search3
   (let [points {[0.0   0.0]    1
@@ -79,11 +78,11 @@
                 [37.759859 -122.437134] :SanFrancisco}
         search (make-nearest-neighbor-search d/euclidean (keys points))]
     (is (= :SanJose
-           (-> (search 2 ((map-invert points) :SantaCruz)) second pq/item-value points)))
+           (-> (search 2 ((map-invert points) :SantaCruz)) second item-value points)))
     (is (= :SanFrancisco
-           (-> (search 2 ((map-invert points) :Berkeley)) second pq/item-value points)))
+           (-> (search 2 ((map-invert points) :Berkeley)) second item-value points)))
     (is (= :MountainView
-           (-> (search 2 ((map-invert points) :PaloAlto)) second pq/item-value points)))))
+           (-> (search 2 ((map-invert points) :PaloAlto)) second item-value points)))))
 
 (deftest test-nearest-neighbor-search-metadata
   (let [points [[:a 2 3]
@@ -93,10 +92,10 @@
                 [:e 8 1]
                 [:f 7 2]]
         search (make-nearest-neighbor-search d/euclidean rest points)]
-    (is (= :f (first (pq/item-value (second (search 2 [:e 8 1]))))))
-    (is (= :b (first (pq/item-value (second (search 2 [:a 2 3]))))))
-    (is (= :e (first (pq/item-value (second (search 2 [:f 7 2]))))))
-    (is (= :b (first (pq/item-value (second (search 2 [:d 4 7]))))))))
+    (is (= :f (first (item-value (second (search 2 [:e 8 1]))))))
+    (is (= :b (first (item-value (second (search 2 [:a 2 3]))))))
+    (is (= :e (first (item-value (second (search 2 [:f 7 2]))))))
+    (is (= :b (first (item-value (second (search 2 [:d 4 7]))))))))
 
 (deftest test-nearest-neighbors-classifier
   (let [data [[25 40000  :no]