kdtree 0.3 → 0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8fa26faf959cacb1da1692bef2539c89031037f4a2c5f715eadc5fed72fa5590
+  data.tar.gz: 3377e4521781a8a675840bf5ac7a34998bbd43783643f0b2ab4ee9988d85465d
+SHA512:
+  metadata.gz: 7f50f4e1721d3ad2359ac3c3ebf8436a5716a4b333e4cc6de3f1443624417b5cecdabb9a25a76f52baf89014b3a70ca699ae4920657ec384305275fcc01a2c3d
+  data.tar.gz: 2075eea9b92b86c547e70a5802df0c2af13554ec43ac92ddedd85d4012d02219ddfa646dabed4e81edb125af363ecc26ad5357b797931184a0a8f3dd8eba53b3

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Adam Doppelt
+Copyright (c) 2025 Adam Doppelt
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,70 +1,115 @@
-## Kdtree
+## Kdtree [![test](https://github.com/gurgeous/kdtree/actions/workflows/test.yml/badge.svg)](https://github.com/gurgeous/kdtree/actions/workflows/test.yml)
+
 
 A kd tree is a data structure that recursively partitions the world in order to rapidly answer nearest neighbor queries. A generic kd tree can support any number of dimensions, and can return either the nearest neighbor or a set of N nearest neighbors.
 
 This gem is a blazingly fast, native, 2d kdtree. It's specifically built to find the nearest neighbor when searching millions of points. It's used in production at Urbanspoon and several other companies.
 
-The first version of this gem was released back in 2009. See the original [blog post](http://gurge.com/2009/10/22/ruby-nearest-neighbor-fast-kdtree-gem/) for the full story. Wikipedia has a great [article on kdtrees](http://en.wikipedia.org/wiki/K-d_tree).
+The first version of this gem was released back in 2009. Wikipedia has a great [article on kdtrees](http://en.wikipedia.org/wiki/K-d_tree).
+
+Note: kdtree obsoletes these forks: ghazel-kdtree, groupon-kdtree, tupalo-kdree. Thanks guys!
+
+### Installation
+
+```ruby
+# install gem
+$ gem install kdtree
+
+# or add to your Gemfile
+gem "kdtree"
+```
 
 ### Usage
 
-Usage is very simple:
+It's easy to use:
+
+- **Kdtree.new(points)** - construct a new tree. Each point should be of the form `[x, y, id]`, where `x/y` are floats and `id` is an int. Not a string, not an object, **just an int**.
+- **kd.nearest(x, y)** - find the nearest point. Returns an id.
+- **kd.nearestk(x, y, k)** - find the nearest `k` points. Returns an array of ids.
 
-* **Kdtree.new(points)** - construct a new tree. Each point should be of the form `[x, y, id]`, where `x/y` are floats and `id` is an int. Not a string, not an object, just an int.
-* **kd.nearest(x, y)** - find the nearest point. Returns an id.
-* **kd.nearestk(x, y, k)** - find the nearest `k` points. Returns an array of ids.
+For example:
 
-Also, I made it possible to **persist** the tree to disk and load it later. That way you can calculate the tree offline and load it quickly at some future point. Loading a persisted tree w/ 1 millions points takes less than a second, as opposed to the 3.5 second startup time shown above. For example:
+```ruby
+# construct the tree
+points = []
+points << [47.6, -122.3, 1] # Seattle id=1
+points << [45.5, -122.8, 2] # Portland id=2
+points << [40.7, -74.0,  3] # New York id=3
+kd = Kdtree.new(points)
+
+# which city is closest to San Francisco?
+p kd.nearest(34.1, -118.2) # => 2
+# which two cities are closest to San Francisco?
+p kd.nearestk(34.1, -118.2, 2) # => [2, 1]
+```
+
+Also, I made it possible to **persist** the tree to disk and load it later. That way you can calculate the tree offline and load it quickly at some future point. Loading a persisted tree w/ 1 millions points takes half a second, as opposed to the 3.5 second build time shown below. At Urbanspoon we persist the tree and rsync it out to other machines. For example:
 
 ```ruby
 File.open("treefile", "w") { |f| kd.persist(f) }
-... later ...
+# ... later ...
 kd2 = File.open("treefile") { |f| Kdtree.new(f) }
 ```
 
 ### Performance
 
-Kdtree is fast. How fast? Using a tree with 1 million points on my i5 2.8ghz:
+Kdtree is fast. How fast? Using a tree with 1 million points on my M1:
 
 ```
-build               3.5s
-nearest point       0.000003s
-nearest 5 points    0.000004s
-nearest 50 points   0.000014s
-nearest 255 points  0.000063s
+build (init)        0.96s
+persist             0.000814s
+read (init)         0.009236s
+
+nearest point       0.000002s
+nearest 5 points    0.000002s
+nearest 50 points   0.000006s
+nearest 255 points  0.000026s
 ```
 
 ### Limitations
 
-* No **editing** allowed! Once you construct a tree you&#8217;re stuck with it.
-* The tree is stored in **one big memory block**, 20 bytes per point. A tree with one million points will allocate a single 19mb block to store its nodes.
-* Persisted trees are **architecture dependent**, and may not work across different machines due to endian issues.
-* nearestk is limited to **255 results**
+- No **editing** allowed! Once you construct a tree you're stuck with it.
+- The tree is stored in **one big memory block**, 20 bytes per point. A tree with one million points will allocate a single 19mb block to store its nodes.
+- Persisted trees are **architecture dependent**, and may not work across different machines due to endian issues.
+- nearestk is limited to **255 results**
 
 ### Contributors
 
 Since this gem was originally released, several folks have contributed important patches:
 
-* @antifuchs (thread safety)
-* @evanphx (native cleanups, perf)
-* @ghazel (C89 compliance)
-* @mcerna (1.9 compat)
+- @antifuchs (thread safety)
+- @evanphx (native cleanups, perf)
+- @ghazel (C89 compliance)
+- @mcerna (1.9 compat)
 
 ### Changelog
 
-#### 0.3 (in progress, unreleased)
+Note: This gem is stable, maintained and continues to work great with all modern versions of Ruby MRI. Our CI tests through Ruby 3.4. No need for new releases until something breaks!
+
+#### 0.5 - May 2025
+
+- justfile
+- hygiene - updated deps, format/lint, modernize rakefile
+- moved to ruby 3.x or higher, tested with ruby 3.4
+- updated benchmark numbers (still real fast)
+
+#### 0.4 - Mar 2017
+
+- this is mostly housekeeping - test on more rubies, fix a few warnings
+
+#### 0.3 - Oct 2012
 
-* Ruby 1.9.x compatibility (@mcerna and others)
-* renamed KDTree to the more idiomatic Kdtree
-* use IO methods directly instead of rooting around in rb_io
-* thread safe, no more statics (@antifuchs)
-* C90 compliance, no warnings (@ghazel)
-* native cleanups (@evanphx)
+- Ruby 1.9.x compatibility (@mcerna and others)
+- renamed KDTree to the more idiomatic Kdtree
+- use IO methods directly instead of rooting around in rb_io
+- thread safe, no more statics (@antifuchs)
+- C90 compliance, no warnings (@ghazel)
+- native cleanups (@evanphx)
 
 #### 0.2
 
 skipped this version to prevent confusion with other flavors of the gem
 
-#### 0.1
+#### 0.1 - Jan 2010
 
-* Original release
+- Original release

data/ext/kdtree/kdtree.c

@@ -5,16 +5,14 @@
 //
 
 // the tree itself
-typedef struct kdtree_data
-{
+typedef struct kdtree_data {
     int root;
     int len;
     struct kdtree_node *nodes;
 } kdtree_data;
 
 // a node in the tree
-typedef struct kdtree_node
-{
+typedef struct kdtree_node {
     float x, y;
     int id;
     int left;
@@ -28,7 +26,7 @@ typedef struct kresult {
 } kresult;
 
 // helper macro for digging out our struct
-#define KDTREEP \
+#define KDTREEP                  \
     struct kdtree_data *kdtreep; \
     Data_Get_Struct(kdtree, struct kdtree_data, kdtreep);
 
@@ -43,8 +41,10 @@ static VALUE kdtree_to_s(VALUE kdtree);
 
 // kdtree helpers
 static int kdtree_build(struct kdtree_data *kdtreep, int min, int max, int depth);
-static void kdtree_nearest0(struct kdtree_data *kdtreep, int i, float x, float y, int depth, int *n_index, float *n_dist);
-static void kdtree_nearestk0(struct kdtree_data *kdtreep, int i, float x, float y, int k, int depth, kresult *k_list, int *k_len, float *k_dist);
+static void kdtree_nearest0(struct kdtree_data *kdtreep, int i, float x, float y, int depth,
+                            int *n_index, float *n_dist);
+static void kdtree_nearestk0(struct kdtree_data *kdtreep, int i, float x, float y, int k, int depth,
+                             kresult *k_list, int *k_len, float *k_dist);
 
 // io helpers
 static void read_all(VALUE io, void *buf, int len);
@@ -59,16 +59,14 @@ static ID id_read, id_write, id_binmode;
 // implementation
 //
 
-static VALUE kdtree_alloc(VALUE klass)
-{
+static VALUE kdtree_alloc(VALUE klass) {
     struct kdtree_data *kdtreep;
     VALUE obj = Data_Make_Struct(klass, struct kdtree_data, 0, kdtree_free, kdtreep);
     kdtreep->root = -1;
     return obj;
 }
 
-static void kdtree_free(struct kdtree_data *kdtreep)
-{
+static void kdtree_free(struct kdtree_data *kdtreep) {
     if (kdtreep) {
         free(kdtreep->nodes);
     }
@@ -95,15 +93,14 @@ static void kdtree_free(struct kdtree_data *kdtreep)
  * kdtree. This makes it possible to build the tree in advance, persist it, and
  * start it up quickly later. See persist for more information.
  */
-static VALUE kdtree_initialize(VALUE kdtree, VALUE arg)
-{
+static VALUE kdtree_initialize(VALUE kdtree, VALUE arg) {
     KDTREEP;
 
     if (TYPE(arg) == T_ARRAY) {
         // init from array of pints
         VALUE points = arg;
         int i;
-        kdtreep->len = RARRAY_LEN(points);
+        kdtreep->len = (int)RARRAY_LEN(points);
         kdtreep->nodes = ALLOC_N(struct kdtree_node, kdtreep->len);
 
         for (i = 0; i < RARRAY_LEN(points); ++i) {
@@ -147,23 +144,20 @@ static VALUE kdtree_initialize(VALUE kdtree, VALUE arg)
     return kdtree;
 }
 
-static int comparex(const void *pa, const void *pb)
-{
-    float a = ((const struct kdtree_node*)pa)->x;
-    float b = ((const struct kdtree_node*)pb)->x;
+static int comparex(const void *pa, const void *pb) {
+    float a = ((const struct kdtree_node *)pa)->x;
+    float b = ((const struct kdtree_node *)pb)->x;
     return (a < b) ? -1 : ((a > b) ? 1 : 0);
 }
 
-static int comparey(const void *pa, const void *pb)
-{
-    float a = ((const struct kdtree_node*)pa)->y;
-    float b = ((const struct kdtree_node*)pb)->y;
+static int comparey(const void *pa, const void *pb) {
+    float a = ((const struct kdtree_node *)pa)->y;
+    float b = ((const struct kdtree_node *)pb)->y;
     return (a < b) ? -1 : ((a > b) ? 1 : 0);
 }
 
-static int kdtree_build(struct kdtree_data *kdtreep, int min, int max, int depth)
-{
-    int(*compar)(const void *, const void *);
+static int kdtree_build(struct kdtree_data *kdtreep, int min, int max, int depth) {
+    int (*compar)(const void *, const void *);
     struct kdtree_node *m;
     int median;
     if (max <= min) {
@@ -198,8 +192,7 @@ static int kdtree_build(struct kdtree_data *kdtreep, int min, int max, int depth
  *   # which city is closest to Boston?
  *   kd.nearest(42.4, -71.1)  #=> 2
  */
-static VALUE kdtree_nearest(VALUE kdtree, VALUE x, VALUE y)
-{
+static VALUE kdtree_nearest(VALUE kdtree, VALUE x, VALUE y) {
     int n_index;
     float n_dist;
     KDTREEP;
@@ -214,8 +207,8 @@ static VALUE kdtree_nearest(VALUE kdtree, VALUE x, VALUE y)
     return INT2NUM((kdtreep->nodes + n_index)->id);
 }
 
-static void kdtree_nearest0(struct kdtree_data *kdtreep, int i, float x, float y, int depth, int *n_index, float *n_dist)
-{
+static void kdtree_nearest0(struct kdtree_data *kdtreep, int i, float x, float y, int depth,
+                            int *n_index, float *n_dist) {
     struct kdtree_node *n;
     float ad;
     int near, far;
@@ -234,11 +227,13 @@ static void kdtree_nearest0(struct kdtree_data *kdtreep, int i, float x, float y
     //
 
     if (ad <= 0) {
-        near = n->left; far = n->right;
+        near = n->left;
+        far = n->right;
     } else {
-        near = n->right; far = n->left;
+        near = n->right;
+        far = n->left;
     }
-    kdtree_nearest0(kdtreep, near,  x, y, depth + 1, n_index, n_dist);
+    kdtree_nearest0(kdtreep, near, x, y, depth + 1, n_index, n_dist);
     if (ad * ad < *n_dist) {
         kdtree_nearest0(kdtreep, far, x, y, depth + 1, n_index, n_dist);
     }
@@ -278,11 +273,11 @@ static void kdtree_nearest0(struct kdtree_data *kdtreep, int i, float x, float y
  *   kd = Kdtree.new(points)
  *
  *   # which two cities are closest to San Francisco?
- *   kd.nearest(34.1, -118.2) #=> [2, 1]
+ *   kd.nearestk(34.1, -118.2, 2) #=> [2, 1]
  */
-static VALUE kdtree_nearestk(VALUE kdtree, VALUE x, VALUE y, VALUE k)
-{
-    // note I leave an extra slot here at the end because of the way our binary insert works
+static VALUE kdtree_nearestk(VALUE kdtree, VALUE x, VALUE y, VALUE k) {
+    // note I leave an extra slot here at the end because of the way our binary
+    // insert works
     kresult k_list[MAX_K + 1];
     int k_len = 0;
     float k_dist = INT_MAX;
@@ -296,7 +291,8 @@ static VALUE kdtree_nearestk(VALUE kdtree, VALUE x, VALUE y, VALUE k)
     } else if (ki > MAX_K) {
         ki = MAX_K;
     }
-    kdtree_nearestk0(kdtreep, kdtreep->root, NUM2DBL(x), NUM2DBL(y), ki, 0, k_list, &k_len, &k_dist);
+    kdtree_nearestk0(kdtreep, kdtreep->root, NUM2DBL(x), NUM2DBL(y), ki, 0, k_list, &k_len,
+                     &k_dist);
 
     // convert result to ruby array
     ary = rb_ary_new();
@@ -306,8 +302,8 @@ static VALUE kdtree_nearestk(VALUE kdtree, VALUE x, VALUE y, VALUE k)
     return ary;
 }
 
-static void kdtree_nearestk0(struct kdtree_data *kdtreep, int i, float x, float y, int k, int depth, kresult *k_list, int *k_len, float *k_dist)
-{
+static void kdtree_nearestk0(struct kdtree_data *kdtreep, int i, float x, float y, int k, int depth,
+                             kresult *k_list, int *k_len, float *k_dist) {
     struct kdtree_node *n;
     float ad;
     int near, far;
@@ -327,11 +323,13 @@ static void kdtree_nearestk0(struct kdtree_data *kdtreep, int i, float x, float
     //
 
     if (ad <= 0) {
-        near = n->left; far = n->right;
+        near = n->left;
+        far = n->right;
     } else {
-        near = n->right; far = n->left;
+        near = n->right;
+        far = n->left;
     }
-    kdtree_nearestk0(kdtreep, near,  x, y, k, depth + 1, k_list, k_len, k_dist);
+    kdtree_nearestk0(kdtreep, near, x, y, k, depth + 1, k_list, k_len, k_dist);
     if (ad * ad < *k_dist) {
         kdtree_nearestk0(kdtreep, far, x, y, k, depth + 1, k_list, k_len, k_dist);
     }
@@ -404,9 +402,7 @@ static void kdtree_nearestk0(struct kdtree_data *kdtreep, int i, float x, float
  *   # later, read the tree from disk
  *   kd2 = File.open("treefile") { |f| Kdtree.new(f) }
  */
-static VALUE kdtree_persist(VALUE kdtree, VALUE io)
-{
-    VALUE str;
+static VALUE kdtree_persist(VALUE kdtree, VALUE io) {
     KDTREEP;
 
     if (!rb_respond_to(io, rb_intern("write"))) {
@@ -428,12 +424,11 @@ static VALUE kdtree_persist(VALUE kdtree, VALUE io)
  *
  * A string that tells you a bit about the tree.
  */
-static VALUE kdtree_to_s(VALUE kdtree)
-{
+static VALUE kdtree_to_s(VALUE kdtree) {
     char buf[256];
     KDTREEP;
 
-    sprintf(buf, "#<%s:%p nodes=%d>", rb_obj_classname(kdtree), (void*)kdtree, kdtreep->len);
+    sprintf(buf, "#<%s:%p nodes=%d>", rb_obj_classname(kdtree), (void *)kdtree, kdtreep->len);
     return rb_str_new(buf, strlen(buf));
 }
 
@@ -441,8 +436,7 @@ static VALUE kdtree_to_s(VALUE kdtree)
 // io helpers
 //
 
-static void read_all(VALUE io, void *buf, int len)
-{
+static void read_all(VALUE io, void *buf, int len) {
     VALUE string = rb_funcall(io, id_read, 1, INT2NUM(len));
     if (NIL_P(string) || RSTRING_LEN(string) != len) {
         rb_raise(rb_eEOFError, "end of file reached");
@@ -450,8 +444,7 @@ static void read_all(VALUE io, void *buf, int len)
     memcpy(buf, RSTRING_PTR(string), len);
 }
 
-static void write_all(VALUE io, const void *buf, int len)
-{
+static void write_all(VALUE io, const void *buf, int len) {
     rb_funcall(io, id_write, 1, rb_str_new(buf, len));
 }
 
@@ -481,14 +474,13 @@ static void write_all(VALUE io, const void *buf, int len)
  *   # which city is closest to San Francisco?
  *   kd.nearest(34.1, -118.2) #=> 2
  *   # which two cities are closest to San Francisco?
- *   kd.nearest(34.1, -118.2) #=> [2, 1]
+ *   kd.nearestk(34.1, -118.2, 2) #=> [2, 1]
  *
  * For more information on kd trees, see:
  *
  * http://en.wikipedia.org/wiki/Kd-tree
  */
-void Init_kdtree()
-{
+void Init_kdtree() {
     static VALUE clazz;
 
     clazz = rb_define_class("Kdtree", rb_cObject);

data/kdtree.gemspec

@@ -1,22 +1,33 @@
 Gem::Specification.new do |s|
-  s.name        = "kdtree"
-  s.version     = "0.3"
+  s.name = "kdtree"
+  s.version = "0.5"
+  s.authors = ["Adam Doppelt"]
+  s.email = "amd@gurge.com"
 
-  s.authors     = ["Adam Doppelt"]
-  s.email       = ["amd@gurge.com"]
-  s.homepage    = "http://github.com/gurgeous/kdtree"
-  s.summary     = "Blazingly fast, native 2d kdtree."
-  s.description = <<EOF
-A kdtree is a data structure that makes it possible to quickly solve
-the nearest neighbor problem. This is a native 2d kdtree suitable for
-production use with millions of points.
-EOF
+  s.summary = "Blazingly fast, native 2d kdtree."
+  s.homepage = "http://github.com/gurgeous/kdtree"
+  s.description = <<~EOF
+    A kdtree is a data structure that makes it possible to quickly solve
+    the nearest neighbor problem. This is a native 2d kdtree suitable for
+    production use with millions of points.
+  EOF
+  s.license = "MIT"
+  s.required_ruby_version = ">= 3.0.0"
+  s.metadata = {
+    "homepage_uri" => s.homepage,
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => s.homepage,
+  }
 
-  s.rubyforge_project = "kdtree"
-  s.add_development_dependency "rake-compiler"
+  s.files = %w[
+    ext/kdtree/extconf.rb
+    ext/kdtree/kdtree.c
+    kdtree.gemspec
+    lib/kdtree.rb
+    LICENSE
+    README.md
+  ]
 
-  s.files      = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.extensions = ["ext/kdtree/extconf.rb"]
   s.require_paths = ["lib"]
 end

metadata

@@ -1,85 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: kdtree
 version: !ruby/object:Gem::Version
-  version: '0.3'
-  prerelease: 
+  version: '0.5'
 platform: ruby
 authors:
 - Adam Doppelt
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-10-17 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-description: ! 'A kdtree is a data structure that makes it possible to quickly solve
-
+date: 2025-05-01 00:00:00.000000000 Z
+dependencies: []
+description: |
+  A kdtree is a data structure that makes it possible to quickly solve
   the nearest neighbor problem. This is a native 2d kdtree suitable for
-
   production use with millions of points.
-
-'
-email:
-- amd@gurge.com
+email: amd@gurge.com
 executables: []
 extensions:
 - ext/kdtree/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - ext/kdtree/extconf.rb
 - ext/kdtree/kdtree.c
 - kdtree.gemspec
 - lib/kdtree.rb
-- test/test_kdtree.rb
 homepage: http://github.com/gurgeous/kdtree
-licenses: []
-post_install_message: 
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://github.com/gurgeous/kdtree
+  rubygems_mfa_required: 'true'
+  source_code_uri: http://github.com/gurgeous/kdtree
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -3094601017742930682
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3094601017742930682
 requirements: []
-rubyforge_project: kdtree
-rubygems_version: 1.8.21
-signing_key: 
-specification_version: 3
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
 summary: Blazingly fast, native 2d kdtree.
 test_files: []

data/.gitignore

@@ -1,4 +0,0 @@
-*.gem
-Gemfile.lock
-lib/*.so
-tmp

data/.travis.yml

@@ -1,9 +0,0 @@
-language: ruby
-rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - rbx-18mode
-  - rbx-19mode
-#  - ruby-head
-  - ree

data/Gemfile

@@ -1,2 +0,0 @@
-source "http://rubygems.org"
-gemspec

data/Rakefile

@@ -1,41 +0,0 @@
-require "bundler/setup"
-require "rake/extensiontask"
-require "rake/testtask"
-
-# load the spec, we use it below
-spec = Gem::Specification.load("kdtree.gemspec")
-
-#
-# gem
-#
-
-task :build do
-  system "gem build --quiet kdtree.gemspec"
-end
-
-task :install => :build do
-  system "sudo gem install --quiet kdtree-#{spec.version}.gem"
-end
-
-task :release => :build do
-  system "git tag -a #{spec.version} -m 'Tagging #{spec.version}'"
-  system "git push --tags"
-  system "gem push kdtree-#{spec.version}.gem"
-end
-
-#
-# rake-compiler
-#
-
-Rake::ExtensionTask.new("kdtree", spec)
-
-
-#
-# testing
-#
-
-Rake::TestTask.new(:test) do |test|
-  test.libs << "test"
-end
-task :test => :compile
-task :default => :test

data/test/test_kdtree.rb

@@ -1,150 +0,0 @@
-require "benchmark"
-require "kdtree"
-require "tempfile"
-require "test/unit"
-
-#
-# create a tree
-#
-
-class KdtreeTest < Test::Unit::TestCase
-  TMP = "#{Dir.tmpdir}/kdtree_test"
-
-  def setup
-    @points = (0...1000).map { |i| [rand_coord, rand_coord, i] }
-    @kdtree = Kdtree.new(@points)
-  end
-
-  def teardown
-    File.unlink(TMP) if File.exists?(TMP)
-  end
-
-  def test_nearest
-    100.times do
-      pt = [rand_coord, rand_coord]
-
-      # kdtree search
-      id = @kdtree.nearest(pt[0], pt[1])
-      kdpt = @points[id]
-
-      # slow search
-      sortpt = @points.sort_by { |i| distance(i, pt) }.first
-
-      # assert
-      kdd = distance(kdpt, pt)
-      sortd = distance(sortpt, pt)
-      assert((kdd - sortd).abs < 0.0000001, "kdtree didn't return the closest result")
-    end
-  end
-
-  def test_nearestk
-    100.times do
-      pt = [rand_coord, rand_coord]
-
-      # kdtree search
-      list = @kdtree.nearestk(pt[0], pt[1], 5)
-      kdpt = @points[list.last]
-
-      # slow search
-      sortpt = @points.sort_by { |i| distance(i, pt) }[list.length - 1]
-
-      # assert
-      kdd = distance(kdpt, pt)
-      sortd = distance(sortpt, pt)
-      assert((kdd - sortd).abs < 0.0000001, "kdtree didn't return the closest result")
-    end
-  end
-
-  def test_persist
-    # write
-    File.open(TMP, "w") { |f| @kdtree.persist(f) }
-    # read
-    kdtree2 = File.open(TMP, "r") { |f| Kdtree.new(f) }
-
-    # now test some random points
-    100.times do
-      pt = [rand_coord, rand_coord]
-      id1 = @kdtree.nearest(*pt)
-      id2 = kdtree2.nearest(*pt)
-      assert(id1 == id2, "kdtree2 differed from kdtree")
-    end
-  end
-
-  def test_bad_magic
-    File.open(TMP, "w") { |f| f.puts "That ain't right" }
-    assert_raise RuntimeError do
-      File.open(TMP, "r") { |f| Kdtree.new(f) }
-    end
-  end
-
-  def test_eof
-    File.open(TMP, "w") { |f| @kdtree.persist(f) }
-    bytes = File.read(TMP)
-
-    [2, 10, 100].each do |len|
-      File.open(TMP, "w") { |f| f.write(bytes[0, len]) }
-      assert_raise EOFError do
-        File.open(TMP, "r") { |f| Kdtree.new(f) }
-      end
-    end
-  end
-
-  def dont_test_speed
-    sizes = [1, 100, 1000, 10000, 100000, 1000000]
-    ks = [1, 5, 50, 255]
-    sizes.each do |s|
-      points = (0...s).map { |i| [rand_coord, rand_coord, i] }
-
-      # build
-      Benchmark.bm(17) do |bm|
-        kdtree = nil
-        bm.report "build" do
-          kdtree = Kdtree.new(points)
-        end
-        bm.report "persist" do
-          File.open(TMP, "w") { |f| kdtree.persist(f) }
-        end
-        bm.report "read" do
-          File.open(TMP, "r") { |f| Kdtree.new(f) }
-        end
-
-        ks.each do |k|
-          bm.report "100 queries (#{k})" do
-            total = count = 0
-            100.times do
-              tm = Time.now
-              if k == 1
-                kdtree.nearest(rand_coord, rand_coord)
-              else
-                kdtree.nearestk(rand_coord, rand_coord, k)
-              end
-            end
-          end
-        end
-      end
-      puts
-    end
-  end
-
-  protected
-
-  def distance(a, b)
-    x, y = a[0] - b[0], a[1] - b[1]
-    x * x + y * y
-  end
-
-  def rand_coord
-    rand(0) * 10 - 5
-  end
-end
-
-# running dont_test_speed on my i5 2.8ghz:
-#
-#                         user     system      total        real
-# build               3.350000   0.020000   3.370000 (  3.520528)
-# persist             0.150000   0.020000   0.170000 (  0.301963)
-# read                0.280000   0.000000   0.280000 (  0.432676)
-# 100 queries (1)     0.000000   0.000000   0.000000 (  0.000319)
-# 100 queries (5)     0.000000   0.000000   0.000000 (  0.000412)
-# 100 queries (50)    0.000000   0.000000   0.000000 (  0.001417)
-# 100 queries (255)   0.000000   0.000000   0.000000 (  0.006268)