geokdtree 0.1.0

data/ext/geokdtree/kdtree.h

@@ -0,0 +1,135 @@
+/*
+This file is part of ``kdtree'', a library for working with kd-trees.
+Copyright (C) 2007-2011 John Tsiombikas <nuclear@member.fsf.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGE.
+*/
+
+/*
+Feb 2013
+included in the ruby-ffi-kdtree gem by Colin Surprenant <colin.surprenant@gmail.com> 
+original source code from https://code.google.com/p/kdtree/ 
+using version 0.5.6 dated Nov 2011
+*/
+
+#ifndef _KDTREE_H_
+#define _KDTREE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct kdtree;
+struct kdres;
+
+#define GEO_UNITS_MI 0
+#define GEO_UNITS_KM 1
+
+/* create a kd-tree for "k"-dimensional data */
+struct kdtree *kd_create(int k);
+
+/* free the struct kdtree */
+void kd_free(struct kdtree *tree);
+
+/* remove all the elements from the tree */
+void kd_clear(struct kdtree *tree);
+
+/* if called with non-null 2nd argument, the function provided
+ * will be called on data pointers (see kd_insert) when nodes
+ * are to be removed from the tree.
+ */
+void kd_data_destructor(struct kdtree *tree, void (*destr)(void*));
+
+/* insert a node, specifying its position, and optional data */
+int kd_insert(struct kdtree *tree, const double *pos, void *data);
+int kd_insert2(struct kdtree *tree, double x, double y, void *data);
+int kd_insert3(struct kdtree *tree, double x, double y, double z, void *data);
+
+/* Find the nearest node from a given point.
+ *
+ * This function returns a pointer to a result set with at most one element.
+ */
+struct kdres *kd_nearest(struct kdtree *tree, const double *pos);
+struct kdres *kd_nearest2(struct kdtree *tree, double x, double y);
+struct kdres *kd_nearest3(struct kdtree *tree, double x, double y, double z);
+
+/* Find the N nearest nodes from a given point.
+ *
+ * This function returns a pointer to a result set, with at most N elements,
+ * which can be manipulated with the kd_res_* functions.
+ * The returned pointer can be null as an indication of an error. Otherwise
+ * a valid result set is always returned which may contain 0 or more elements.
+ * The result set must be deallocated with kd_res_free after use.
+ */
+/*
+struct kdres *kd_nearest_n(struct kdtree *tree, const double *pos, int num);
+struct kdres *kd_nearest_nf(struct kdtree *tree, const float *pos, int num);
+struct kdres *kd_nearest_n3(struct kdtree *tree, double x, double y, double z);
+struct kdres *kd_nearest_n3f(struct kdtree *tree, float x, float y, float z);
+*/
+
+/* Find any nearest nodes from a given point within a range.
+ *
+ * This function returns a pointer to a result set, which can be manipulated
+ * by the kd_res_* functions.
+ * The returned pointer can be null as an indication of an error. Otherwise
+ * a valid result set is always returned which may contain 0 or more elements.
+ * The result set must be deallocated with kd_res_free after use.
+ */
+struct kdres *kd_nearest_range(struct kdtree *tree, const double *pos, const double range);
+struct kdres *kd_nearest_range2(struct kdtree *tree, double x, double y, double range);
+struct kdres *kd_nearest_range3(struct kdtree *tree, double x, double y, double z, double range);
+struct kdres *kd_nearest_geo_range(struct kdtree *kd, double lat, double lng, double range, int units);
+
+/* frees a result set returned by kd_nearest_range() */
+void kd_res_free(struct kdres *set);
+
+/* returns the size of the result set (in elements) */
+int kd_res_size(struct kdres *set);
+
+/* rewinds the result set iterator */
+void kd_res_rewind(struct kdres *set);
+
+/* returns non-zero if the set iterator reached the end after the last element */
+int kd_res_end(struct kdres *set);
+
+/* advances the result set iterator, returns non-zero on success, zero if
+ * there are no more elements in the result set.
+ */
+int kd_res_next(struct kdres *set);
+
+/* returns the data pointer (can be null) of the current result set item
+ * and optionally sets its position to the pointers(s) if not null.
+ */
+void *kd_res_item(struct kdres *set, double *pos);
+void *kd_res_item3(struct kdres *set, double *x, double *y, double *z);
+
+/* equivalent to kd_res_item(set, 0) */
+void *kd_res_item_data(struct kdres *set);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _KDTREE_H_ */

data/geokdtree.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'geokdtree/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "geokdtree"
+  gem.version       = Geokdtree::VERSION
+  gem.authors       = ["Colin Surprenant"]
+  gem.email         = ["colin.surprenant@gmail.com"]
+  gem.description   = "Ruby & JRuby gem with a fast k-d tree C implementation using FFI bindings with support for latitude/longitude and geo distance range search"
+  gem.summary       = "Ruby & JRuby FFI gem with a fast k-d tree C implementation with geo support"
+  gem.homepage      = "http://github.com/colinsurprenant/geokdtree"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.extensions    = ["ext/geokdtree/extconf.rb"]
+
+  gem.add_development_dependency "rspec"
+  gem.add_runtime_dependency "ffi"
+end

data/lib/geokdtree.rb

@@ -0,0 +1,13 @@
+require 'ffi'
+
+module Geokdtree
+  module C
+    extend FFI::Library
+    
+  	ffi_lib File.dirname(__FILE__) + "/" + (FFI::Platform.mac? ? "geokdtree.bundle" : FFI.map_library_name("geokdtree"))
+  end
+end
+
+require 'geokdtree/version'
+require 'geokdtree/tree_ffi'
+require 'geokdtree/tree'

data/lib/geokdtree/tree.rb

@@ -0,0 +1,139 @@
+module Geokdtree
+
+  ResultPoint = Struct.new(:point, :data)
+
+  RADIUS_MI = 3958.760
+  RADIUS_KM = 6371.0
+  KM_PER_MI = 1.609
+
+  GEO_UNITS_MI = 0
+  GEO_UNITS_KM = 1
+
+  class KdtreePointer < FFI::AutoPointer
+
+    def self.release(ptr) 
+      # ptr is the original pointer you passed in to create VectorPointer 
+      C::kd_free(ptr) 
+    end 
+  end 
+
+  class Tree
+
+    def initialize(dimensions)
+      @dimensions = dimensions
+      @tree = KdtreePointer.new(C::kd_create(dimensions))
+      @data_cache = {}
+      @data_id = 0
+    end
+
+    # insert a point of n dimensions and arbritary associated object
+    # @param point [Array<Float>] array of n dimensions of numeric coordinates
+    # @param data [Object] arbritary object stored with point
+    # @return [Tree] self 
+    def insert(point, data = nil)
+      # here we don't actually pass a pointer to our data but the object numeric key encoded into the pointer
+      r = case point.size
+        when 2 then C::kd_insert2(@tree, point[0].to_f, point[1].to_f, cache(data))
+        when 3 then C::kd_insert3(@tree, point[0].to_f, point[1].to_f, point[2].to_f, cache(data))
+        else C::kd_insert(@tree, Tree.allocate_doubles(point), cache(data))
+      end     
+      raise("error on Tree#insert, code=#{r}") unless r.zero?
+      self
+    end
+
+    # find the given point nearest neighbor
+    # @param point [Array<Float>] array of n dimensions of numeric coordinates
+    # @return [ResultPoint] the nearest neighbor, nil if no neighbor
+    def nearest(point)
+      set = case point.size
+        when 2 then C::kd_nearest2(@tree, point[0].to_f, point[1].to_f)
+        when 3 then C::kd_nearest3(@tree, point[0].to_f, point[1].to_f, point[2].to_f)
+        else C::kd_nearest(@tree, Tree.allocate_doubles(point))
+      end
+      return nil if set.null?
+      retrieve_results(set).first
+    end
+
+    # find all the given point neighbors within the given Euclidean range
+    # @param point [Array<Float>] array of n dimensions of numeric coordinates
+    # @param range [Float] range units expressed as a Euclidean distance
+    # @return [Array<ResultPoint>] the point neighbors within range, [] if none
+    def nearest_range(point, range)
+      set = case point.size
+        when 2 then C::kd_nearest_range2(@tree, point[0].to_f, point[1].to_f, range.to_f)
+        when 3 then C::kd_nearest_range3(@tree, point[0].to_f, point[1].to_f, point[2].to_f, range.to_f)
+        else C::kd_nearest_range(@tree, Tree.allocate_doubles(point), range.to_f)
+      end
+      return [] if set.null?
+      retrieve_results(set)
+    end
+
+    # find all the given point neighbors within the given geo range
+    # @param point [Array<Float>] [latitude, longitude] array
+    # @param range [Float] range units in miles or kms, default in miles
+    # @param units [Symbol] :mi or :km, default :mi
+    # @return [Array<ResultPoint>] the point neighbors within range, [] if none
+    def nearest_geo_range(point, range, units = :mi)
+      raise("must have 2 dimensions for geo methods") unless @dimensions == 2
+      set = C::kd_nearest_geo_range(@tree, point[0].to_f, point[1].to_f, range.to_f, units == :mi ? GEO_UNITS_MI : GEO_UNITS_KM)
+      return [] if set.null?
+      retrieve_results(set)
+     end
+
+    # compute the Euclidean distance between 2 points of n dimensions
+    # @param pointa [Array<Float>] array of n dimensions of numeric coordinates
+    # @param pointb [Array<Float>] array of n dimensions of numeric coordinates
+    # @return [Float] the Euclidean distance between the 2 points
+    def self.distance(pointa, pointb)
+      case k = pointa.size
+        when 2 then C::euclidean_distance2(pointa[0].to_f, pointa[1].to_f, pointb[0].to_f, pointb[1].to_f)
+        else C::euclidean_distance(allocate_doubles(pointa), allocate_doubles(pointb), k)
+      end
+    end
+
+    # compute the geo distance between 2 points of latitude, longitude
+    # @param pointa [Array<Float>] [latitude, longitude] array
+    # @param pointb [Array<Float>] [latitude, longitude] array
+    # @param units [Symbol] :mi or :km, default :mi
+    # @return [Float] the geo distance between the 2 points
+    def self.geo_distance(pointa, pointb, units = :mi)
+      C::slc_distance2(pointa[0].to_f, pointa[1].to_f, pointb[0].to_f, pointb[1].to_f, units == :mi ? RADIUS_MI : RADIUS_KM)
+    end
+
+    private
+
+    # store data in cache hash and return pointer encoded numeric object key
+    # @param data [Object] arbritary object
+    # @return [FFI::Pointer] pointer encoded numeric object key 
+    def cache(data)
+      return nil unless data
+      @data_cache[@data_id += 1] = data
+      FFI::Pointer.new(@data_id)
+    end
+
+    # allocate managed memory pointer for given doubles array
+    # @param doubles [Array<Fixnum>] array doubles numbers
+    # @return [FFI::MemoryPointer] pointer to allocated & copied doubles
+    def self.allocate_doubles(doubles)
+      ptr = FFI::MemoryPointer.new(:double, doubles.size)
+      ptr.write_array_of_double(doubles)
+      ptr
+    end
+
+    # walk a result set and transpose into result array
+    # @param set [FFI::Pointer] the result set from tree search functions
+    # @return [Array<ResultPoint>] transposed result items 
+    def retrieve_results(set)
+      results = []
+      while C::kd_res_end(set) == 0 
+        point_ptr = FFI::MemoryPointer.new(:double, @dimensions) # to hold point result
+        data_ptr = C::kd_res_item(set, point_ptr) # fetch single result item  
+        results << ResultPoint.new(point_ptr.read_array_of_double(@dimensions), data_ptr.null? ? nil : @data_cache[data_ptr.address])
+        C::kd_res_next(set)
+      end
+      C::kd_res_free(set)
+      results
+    end
+
+  end
+end

data/lib/geokdtree/tree_ffi.rb

@@ -0,0 +1,92 @@
+require 'ffi'
+
+module Geokdtree::C
+  # /* create a kd-tree for "k"-dimensional data */
+  # struct kdtree *kd_create(int k);
+  attach_function "kd_create", "kd_create", [:int], :pointer
+
+  # /* free the struct kdtree */
+  # void kd_free(struct kdtree *tree);
+  attach_function "kd_free", "kd_free", [:pointer], :void
+
+  # /* remove all the elements from the tree */
+  # void kd_clear(struct kdtree *tree);
+  attach_function "kd_clear", "kd_clear", [:pointer], :void
+
+  # /* insert a node, specifying its position, and optional data */
+  # int kd_insert(struct kdtree *tree, const double *pos, void *data);
+  attach_function "kd_insert", "kd_insert", [:pointer, :pointer, :pointer], :int
+
+  # int kd_insert2(struct kdtree *tree, double x, double y, void *data);
+  attach_function "kd_insert2", "kd_insert2", [:pointer, :double, :double, :pointer], :int
+
+  # int kd_insert3(struct kdtree *tree, double x, double y, double z, void *data);
+  attach_function "kd_insert3", "kd_insert3", [:pointer, :double, :double, :double, :pointer], :int
+
+  # /* Find the nearest node from a given point.
+  #  *
+  #  * This function returns a pointer to a result set with at most one element.
+  #  */
+  # struct kdres *kd_nearest(struct kdtree *tree, const double *pos);
+  attach_function "kd_nearest", "kd_nearest", [:pointer, :pointer], :pointer
+ 
+  # struct kdres *kd_nearest2(struct kdtree *tree, double x, double y);
+  attach_function "kd_nearest2", "kd_nearest2", [:pointer, :double, :double], :pointer
+
+  # struct kdres *kd_nearest2(struct kdtree *tree, double x, double y, double z);
+  attach_function "kd_nearest3", "kd_nearest3", [:pointer, :double, :double, :double], :pointer
+
+  # /* Find any nearest nodes from a given point within a range.
+  #  *
+  #  * This function returns a pointer to a result set, which can be manipulated
+  #  * by the kd_res_* functions.
+  #  * The returned pointer can be null as an indication of an error. Otherwise
+  #  * a valid result set is always returned which may contain 0 or more elements.
+  #  * The result set must be deallocated with kd_res_free after use.
+  #  */
+  # struct kdres *kd_nearest_range(struct kdtree *tree, const double *pos, double range);
+  attach_function "kd_nearest_range", "kd_nearest_range", [:pointer, :pointer, :double], :pointer
+
+  # struct kdres *kd_nearest_range2(struct kdtree *tree, double x, double y, double range);
+  attach_function "kd_nearest_range2", "kd_nearest_range2", [:pointer, :double, :double, :double], :pointer
+
+  # struct kdres *kd_nearest_range3(struct kdtree *tree, double x, double y, double z, double range);
+  attach_function "kd_nearest_range3", "kd_nearest_range3", [:pointer, :double, :double, :double, :double], :pointer
+
+  # struct kdres *kd_nearest_geo_range(struct kdtree *kd, double lat, double lng, double range, int units)
+  attach_function "kd_nearest_geo_range", "kd_nearest_geo_range", [:pointer, :double, :double, :double, :int], :pointer
+
+  # void *kd_res_item(struct kdres *set, double *pos);
+  attach_function "kd_res_item", "kd_res_item", [:pointer, :pointer], :pointer
+
+  # /* frees a result set returned by kd_nearest_range() */
+  # void kd_res_free(struct kdres *set);
+  attach_function "kd_res_free", "kd_res_free", [:pointer], :void
+
+  # /* advances the result set iterator, returns non-zero on success, zero if
+  #  * there are no more elements in the result set.
+  #  */
+  # int kd_res_next(struct kdres *set);
+  attach_function "kd_res_next", "kd_res_next", [:pointer], :int
+
+  # /* returns non-zero if the set iterator reached the end after the last element */
+  # int kd_res_end(struct kdres *set);
+  attach_function "kd_res_end", "kd_res_end", [:pointer], :int
+
+  # /* return the Euclidean distance from two points in k dimensions */
+  # double euclidean_distance( double *a, double *b, int k );
+  attach_function "euclidean_distance", "euclidean_distance", [:pointer, :pointer, :int], :double
+
+  # /* return the Euclidean distance from two points in two dimensions */
+  # double euclidean_distance2(double ax, double ay, double bx, double by);
+  attach_function "euclidean_distance2", "euclidean_distance2", [:double, :double, :double, :double], :double
+
+  # /* return the geo distance from two lat/lng points using the spherical law of cosines */
+  # double slc_distance(double *a, double *b, double radius) {
+  attach_function "slc_distance", "slc_distance", [:pointer, :pointer, :double], :double
+
+  # /* return the geo distance from two lat/lng points using the spherical law of cosines */
+  # double slc_distance2(double lat1, double lng1, double lat2, double lng2, double radius) {
+  attach_function "slc_distance2", "slc_distance2", [:double, :double, :double, :double, :double], :double
+
+end

data/lib/geokdtree/version.rb

@@ -0,0 +1,3 @@
+module Geokdtree
+  VERSION = "0.1.0"
+end

data/spec/geokdtree/geokdtree_spec.rb

@@ -0,0 +1,209 @@
+require 'rspec'
+require 'geokdtree'
+
+describe Geokdtree::Tree do
+
+  before do
+    @points = {
+      :top_left => [-1, -1],
+      :mid_upper_left => [-0.5, -0.5],
+      :top_right => [1, -1],
+      :mid_upper_right => [0.5, -0.5],
+      :center => [0, 0],
+      :mid_lower_left => [-0.5, 0.5],
+      :bottom_left => [-1, 1],
+      :mid_lower_right => [0.5, 0.5],
+      :bottom_right => [1, 1],
+    }
+
+    @places = {
+      :seattle => [47.6, -122.3],
+      :portland => [45.5, -122.8], 
+      :new_york => [40.7, -74.0],
+      :los_angeles => [34.1, -118.2],
+      :montreal => [45.50, -73.55],
+    }
+    @insert_places = [:seattle, :portland, :new_york]
+  end
+
+  it "should initialize" do
+    tree = Geokdtree::Tree.new(2)
+    tree.should_not be_nil
+  end
+
+  it "should find neighbors in a 2D tree without data" do
+    # this spec inspired by https://github.com/sdeming/ffi-kdtree/blob/master/spec/find_nearest_spec.rb
+    tree = Geokdtree::Tree.new(2)
+    @points.each{|k, p| tree.insert(p)}
+
+    result = tree.nearest([0, 0])
+    result.point.should == [0, 0]
+    result.data.should be_nil
+
+    result = tree.nearest([0.3, 0.3])
+    result.point.should == [0.5, 0.5]
+    result.data.should be_nil
+
+    result = tree.nearest([-0.3, -0.3])
+    result.point.should == [-0.5, -0.5]
+    result.data.should be_nil
+
+    result = tree.nearest([0.1,0.1])
+    result.point.should == [0, 0]
+    result.data.should be_nil
+
+    results = tree.nearest_range([0, 0], 2)
+    results.size.should == 9 
+
+    results = tree.nearest_range([0, 0], 1)
+    results.size.should == 5 # center + mids
+
+    tree.nearest_range([10, 10], 1).should == []
+  end
+
+  it "should find neighbors in a 2D tree using data" do
+    # this spec inspired by https://github.com/sdeming/ffi-kdtree/blob/master/spec/find_nearest_spec.rb
+    tree = Geokdtree::Tree.new(2)
+
+    @points.each{|k, p| tree.insert(p, k)}
+
+    result = tree.nearest([0, 0])
+    result.point.should == [0, 0]
+    result.data.should == :center
+
+    result = tree.nearest([0.3, 0.3])
+    result.point.should == [0.5, 0.5]
+    result.data.should == :mid_lower_right
+
+    result = tree.nearest([-0.3, -0.3])
+    result.point.should == [-0.5, -0.5]
+    result.data.should == :mid_upper_left
+
+    result = tree.nearest([0.1,0.1])
+    result.point.should == [0, 0]
+    result.data.should == :center
+
+    results = tree.nearest_range([0, 0], 2)
+    results.size.should == 9
+    results.map(&:data).sort.should == @points.to_a.map(&:first).sort
+
+    results = tree.nearest_range([0, 0], 1)
+    results.map(&:data).sort.should == [:mid_upper_left, :mid_upper_right, :center, :mid_lower_left, :mid_lower_right].sort
+
+    results = tree.nearest_range([10, 10], 1).should == []
+  end
+
+  it "should not find any neighbor in an empty tree" do
+    tree = Geokdtree::Tree.new(2)
+    tree.nearest([0, 0]).should be_nil
+    tree = Geokdtree::Tree.new(3)
+    tree.nearest([0, 0, 0]).should be_nil
+   end
+
+  it "should find nearest by latlong" do
+    tree = Geokdtree::Tree.new(2)
+    @insert_places.each{|p| tree.insert(@places[p], p)}
+
+    tree.nearest(@places[:los_angeles]).data.should == :portland
+    tree.nearest(@places[:montreal]).data.should == :new_york
+  end
+
+  it "should find nearest geo range by latlong" do
+    tree = Geokdtree::Tree.new(2)
+    @insert_places.each{|p| tree.insert(@places[p], p)}
+
+    tree.nearest_geo_range(@places[:los_angeles], 0).size.should == 0
+    tree.nearest_geo_range(@places[:los_angeles], 800).size.should == 0
+
+    tree.nearest_geo_range(@places[:los_angeles], 900).size.should == 1
+    tree.nearest_geo_range(@places[:los_angeles], 900).first.data.should == :portland
+    tree.nearest_geo_range(@places[:los_angeles], 900, :mi).size.should == 1
+    tree.nearest_geo_range(@places[:los_angeles], 900, :mi).first.data.should == :portland
+
+    tree.nearest_geo_range(@places[:los_angeles], 900, :km).size.should == 0
+    tree.nearest_geo_range(@places[:los_angeles], 1448, :km).size.should == 1
+    tree.nearest_geo_range(@places[:los_angeles], 1448, :km).first.data.should == :portland
+
+    tree.nearest_geo_range(@places[:los_angeles], 957).size.should == 2
+    tree.nearest_geo_range(@places[:los_angeles], 957).map(&:data).sort.should == [:portland, :seattle].sort
+    tree.nearest_geo_range(@places[:los_angeles], 957, :mi).size.should == 2
+    tree.nearest_geo_range(@places[:los_angeles], 957, :mi).map(&:data).sort.should == [:portland, :seattle].sort
+    tree.nearest_geo_range(@places[:los_angeles], 1540, :km).size.should == 2
+    tree.nearest_geo_range(@places[:los_angeles], 1540, :km).map(&:data).sort.should == [:portland, :seattle].sort
+
+    tree.nearest_geo_range(@places[:los_angeles], 2500).size.should == 3
+    tree.nearest_geo_range(@places[:los_angeles], 2500).map(&:data).sort.should == [:portland, :seattle, :new_york].sort
+    tree.nearest_geo_range(@places[:los_angeles], 2500, :mi).size.should == 3
+    tree.nearest_geo_range(@places[:los_angeles], 2500, :mi).map(&:data).sort.should == [:portland, :seattle, :new_york].sort
+    tree.nearest_geo_range(@places[:los_angeles], 4023, :km).size.should == 3
+    tree.nearest_geo_range(@places[:los_angeles], 4023, :km).map(&:data).sort.should == [:portland, :seattle, :new_york].sort
+
+    tree.insert(@places[:los_angeles], :los_angeles)
+
+    tree.nearest_geo_range(@places[:los_angeles], 0).size.should == 1
+    tree.nearest_geo_range(@places[:los_angeles], 0).first.data.should == :los_angeles
+    tree.nearest_geo_range(@places[:los_angeles], 0, :mi).size.should == 1
+    tree.nearest_geo_range(@places[:los_angeles], 0, :mi).first.data.should == :los_angeles
+    tree.nearest_geo_range(@places[:los_angeles], 0, :km).size.should == 1
+    tree.nearest_geo_range(@places[:los_angeles], 0, :km).first.data.should == :los_angeles
+
+    tree.nearest_geo_range(@places[:montreal], 900).size.should == 1
+    tree.nearest_geo_range(@places[:montreal], 900).first.data.should == :new_york
+    tree.nearest_geo_range(@places[:montreal], 900, :mi).size.should == 1
+    tree.nearest_geo_range(@places[:montreal], 900, :mi).first.data.should == :new_york
+    tree.nearest_geo_range(@places[:montreal], 1448, :km).size.should == 1
+    tree.nearest_geo_range(@places[:montreal], 1448, :km).first.data.should == :new_york
+  end
+
+  it "should find nearest using random points" do
+    tree = Geokdtree::Tree.new(2)
+    random_points = (0...1000).map{|i| [[rand_coord, rand_coord], i]}
+    random_points.each{|p| tree.insert(p.first, p.last)}
+
+    100.times do
+      random_point = [rand_coord, rand_coord]
+
+      # tree search
+      result = tree.nearest(random_point)
+      kd_nearest_point = random_points[result.data].first
+
+      # sort search
+      sort_nearest_point = random_points.sort_by{|i| Geokdtree::Tree.distance(i.first, random_point)}.first.first
+
+      Geokdtree::Tree.distance(sort_nearest_point, random_point).should == Geokdtree::Tree.distance(kd_nearest_point, random_point)
+    end
+  end
+
+  it "should compute geo distance" do
+    Geokdtree::Tree.geo_distance(@places[:los_angeles], @places[:portland]).round(0).should == 824
+    Geokdtree::Tree.geo_distance(@places[:los_angeles], @places[:seattle]).round(0).should == 957
+    Geokdtree::Tree.geo_distance(@places[:los_angeles], @places[:new_york]).round(0).should == 2442
+    Geokdtree::Tree.geo_distance(@places[:montreal], @places[:new_york]).round(0).should == 332
+
+    Geokdtree::Tree.geo_distance(@places[:los_angeles], @places[:portland], :mi).round(0).should == 824
+    Geokdtree::Tree.geo_distance(@places[:los_angeles], @places[:seattle], :mi).round(0).should == 957
+    Geokdtree::Tree.geo_distance(@places[:los_angeles], @places[:new_york], :mi).round(0).should == 2442
+    Geokdtree::Tree.geo_distance(@places[:montreal], @places[:new_york],:mi).round(0).should == 332
+
+    Geokdtree::Tree.geo_distance(@places[:los_angeles], @places[:portland], :km).round(0).should == 1327
+    Geokdtree::Tree.geo_distance(@places[:los_angeles], @places[:seattle], :km).round(0).should == 1540
+    Geokdtree::Tree.geo_distance(@places[:los_angeles], @places[:new_york], :km).round(0).should == 3931
+    Geokdtree::Tree.geo_distance(@places[:montreal], @places[:new_york], :km).round(0).should == 535
+  end
+
+  it "should compute distance" do
+    Geokdtree::Tree.distance([-1, 1], [1, 1]).should == 2    
+    Geokdtree::Tree.distance([-1, 1], [-1, -1]).should == 2
+    Geokdtree::Tree.distance([1, 1], [1, 0]).should == 1
+    Geokdtree::Tree.distance([0, 0], [-1, 0]).should == 1
+    Geokdtree::Tree.distance([0, 0], [0, -1]).should == 1
+    Geokdtree::Tree.distance([-0.5, -0.5], [0.5, -0.5]).should == 1
+    Geokdtree::Tree.distance([-0.5, -0.5], [0, -0.5]).should == 0.5
+  end
+
+end
+
+def rand_coord
+  rand(0) * 10 - 5
+end
+