fast_nearest_latlng 0.0.2

data/LICENSE

@@ -0,0 +1,51 @@
+Copyright (c) 2012 Todd Fisher (todd.fisher@gmail.com).
+Fast Nearest latlng is free software licensed under the following terms:
+
+1. You may make and give away verbatim copies of the source form of the
+   software without restriction, provided that you duplicate all of the
+   original copyright notices and associated disclaimers.
+
+2. You may modify your copy of the software in any way, provided that
+   you do at least ONE of the following:
+
+     a) place your modifications in the Public Domain or otherwise
+        make them Freely Available, such as by posting said
+  modifications to Usenet or an equivalent medium, or by allowing
+  the author to include your modifications in the software.
+
+     b) use the modified software only within your corporation or
+        organization.
+
+     c) give non-standard binaries non-standard names, with
+        instructions on where to get the original software distribution.
+
+     d) make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or binary form,
+   provided that you do at least ONE of the following:
+
+     a) distribute the binaries and library files of the software,
+  together with instructions (in the manual page or equivalent)
+  on where to get the original distribution.
+
+     b) accompany the distribution with the machine-readable source of
+  the software.
+
+     c) give non-standard binaries non-standard names, with
+        instructions on where to get the original software distribution.
+
+     d) make other distribution arrangements with the author.
+
+4. You may modify and include the part of the software into any other
+   software (possibly commercial).
+
+5. The scripts and library files supplied as input to or produced as 
+   output from the software do not automatically fall under the
+   copyright of the software, but belong to whomever generated them, 
+   and may be sold commercially, and may be aggregated with this
+   software.
+
+6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE.

data/README

@@ -0,0 +1,11 @@
+find the nearest locations to a given point
+
+
+    floc = FastLoc.new(:unit => :miles) # :kilometers or :nautical_miles
+
+    floc.add(latdeg,lngdeg,3)
+    floc.add(latdeg,lngdeg,4)
+    floc.add(latdeg,lngdeg,5)
+    floc.add(latdeg,lngdeg,6)
+
+    floc.nearest(latdeg,lngdeg) -> [5,3,4,6]

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+dir_config('fastloc')
+create_makefile('fastloc')

data/ext/fastloc.c

@@ -0,0 +1,224 @@
+#include <ruby.h>
+#include <stdlib.h>
+#include <math.h>
+
+VALUE cFastLoc;
+VALUE cFastLoc;
+
+#define pi 3.14159265358979323846
+
+typedef struct {
+  int id;
+  double lat, lng;
+} Location;
+
+typedef struct {
+  int id;
+  double dist;
+} ldat;
+
+typedef struct {
+  Location **locations;
+  size_t count;
+  char unit;
+} ruby_fast_loc;
+
+static double deg2rad(double deg) {
+  return (deg * pi / 180);
+}
+
+static double rad2deg(double rad) {
+  return (rad * 180 / pi);
+}
+
+// see: http://www.zipcodeworld.com/samples/distance.c.html
+static double distance(double lat1, double lon1, double lat2, double lon2, char unit) {
+  double theta, dist;
+  theta = lon1 - lon2;
+  dist = sin(deg2rad(lat1)) * sin(deg2rad(lat2)) + cos(deg2rad(lat1)) * cos(deg2rad(lat2)) * cos(deg2rad(theta));
+  dist = acos(dist);
+  dist = rad2deg(dist);
+  dist = dist * 60 * 1.1515;
+  switch(unit) {
+  case 'M':
+    break;
+  case 'K':
+    dist = dist * 1.609344;
+    break;
+  case 'N':
+    dist = dist * 0.8684;
+    break;
+  }
+  return (dist);
+}
+
+static VALUE ruby_fast_loc_add(VALUE self, VALUE latdeg, VALUE lngdeg, VALUE id) {
+  int i = 0, count = 0;
+  VALUE add;
+  ruby_fast_loc *floc;
+
+  Data_Get_Struct(self, ruby_fast_loc, floc);
+
+  floc->count++;
+
+  Location **locations = (Location**)malloc(sizeof(Location*)*floc->count);
+
+  Location *location = (Location*)malloc(sizeof(Location));
+
+  location->lat = NUM2DBL(latdeg);
+  location->lng = NUM2DBL(lngdeg);
+  location->id  = FIX2INT(id);
+  locations[floc->count-1] = location;
+
+  if (floc->locations) {
+    count = floc->count-1;
+    for (i = 0; i < count; ++i) {
+      locations[i] = floc->locations[i];
+    }
+    free(floc->locations);
+  }
+  floc->locations = locations;
+
+  return self;
+}
+static int distance_compare(const void *a, const void *b) {
+  ldat* v1 = ((ldat*)a);
+  ldat* v2 = ((ldat*)b);
+  if (v1->dist < v2->dist) { return -1; }
+  else if (v1->dist == v2->dist) { return 0; }
+  return 1;
+}
+
+static VALUE ruby_fast_loc_nearest(VALUE self, VALUE latdeg, VALUE lngdeg) {
+  VALUE sorted = rb_ary_new();
+  ruby_fast_loc *floc;
+
+  Data_Get_Struct(self, ruby_fast_loc, floc);
+  int i = 0;
+  double lat = NUM2DBL(latdeg);
+  double lng = NUM2DBL(lngdeg);
+  ldat distances[floc->count];
+
+  for (i = 0; i < floc->count; ++i) {
+    distances[i].id = floc->locations[i]->id;
+    distances[i].dist = distance(lat, lng, floc->locations[i]->lat, floc->locations[i]->lng, floc->unit);
+  }
+
+  // void qsort(void *base, size_t nel, size_t width, int (*compar)(const void *, const void *));
+  qsort(distances, floc->count, sizeof(ldat), distance_compare);
+
+  for (i = 0; i < floc->count; ++i) {
+    VALUE result = rb_ary_new2(2);
+    rb_ary_push(result, rb_float_new(distances[i].dist));
+    rb_ary_push(result, rb_int_new(distances[i].id));
+    rb_ary_push(sorted, result);
+  }
+  return sorted;
+}
+
+static VALUE ruby_fast_loc_locations(VALUE self) {
+  ruby_fast_loc *floc;
+
+  Data_Get_Struct(self, ruby_fast_loc, floc);
+
+  if (!floc->count) {
+    return rb_ary_new();
+  }
+
+  VALUE add = Qnil;
+  VALUE locations = rb_ary_new();
+  int i;
+  Location *location;
+
+  for (i = 0; i < floc->count && floc->locations; ++i) {
+    location = floc->locations[i];
+
+    add = rb_ary_new2(3);
+    rb_ary_push(add, rb_float_new(location->lat));
+    rb_ary_push(add, rb_float_new(location->lng));
+    rb_ary_push(add, rb_int_new(location->id));
+    rb_ary_push(locations, add);
+  }
+
+  return locations;
+}
+static VALUE ruby_fast_loc_get_unit(VALUE self) {
+  ruby_fast_loc *floc;
+
+  Data_Get_Struct(self, ruby_fast_loc, floc);
+
+  return rb_str_new(&floc->unit,1);
+}
+
+static VALUE ruby_fast_loc_set_unit(VALUE self, VALUE unit_sym) {
+  ruby_fast_loc *floc;
+
+  Data_Get_Struct(self, ruby_fast_loc, floc);
+
+  if (unit_sym == ID2SYM(rb_intern("miles"))) {
+    floc->unit = 'M';
+  } else if (unit_sym == ID2SYM(rb_intern("kilometers"))) {
+    floc->unit = 'K';
+  } else if (unit_sym == ID2SYM(rb_intern("nautical_miles"))) {
+    floc->unit = 'N';
+  }
+
+  return rb_str_new(&floc->unit,1);
+}
+
+void fast_loc_mark(ruby_fast_loc *floc) {
+}
+
+static void fast_loc_clear(ruby_fast_loc *floc) {
+  while(floc->count) {
+    free(floc->locations[--floc->count]);
+  }
+  free(floc->locations);
+  floc->locations = NULL;
+}
+static void fast_loc_free(ruby_fast_loc *floc) {
+  fast_loc_clear(floc);
+  free(floc);
+}
+
+
+static VALUE ruby_fast_loc_new(int argc, VALUE *argv, VALUE klass) {
+  VALUE new_floc, options, unit_sym;
+  ruby_fast_loc *floc;
+
+  rb_scan_args(argc, argv, "01", &options);
+
+  floc = ALLOC(ruby_fast_loc);
+  floc->unit = 'M';
+  floc->locations = NULL;
+  floc->count = 0;
+
+  new_floc = Data_Wrap_Struct(klass, fast_loc_mark, fast_loc_free, floc);
+
+  if (!NIL_P(options) && TYPE(options) == T_HASH) {
+    unit_sym = rb_hash_aref(options, ID2SYM(rb_intern("unit")));
+    ruby_fast_loc_set_unit(new_floc, unit_sym);
+  }
+
+  return new_floc;
+}
+static VALUE ruby_fast_loc_reset(VALUE self) {
+  ruby_fast_loc *floc;
+
+  Data_Get_Struct(self, ruby_fast_loc, floc);
+
+  fast_loc_clear(floc);
+
+  return self;
+}
+
+void Init_fastloc() {
+  cFastLoc = rb_define_class("FastLoc", rb_cObject);
+  rb_define_singleton_method(cFastLoc, "new", ruby_fast_loc_new, -1);
+  rb_define_method(cFastLoc, "add", ruby_fast_loc_add, 3);
+  rb_define_method(cFastLoc, "unit", ruby_fast_loc_get_unit, 0);
+  rb_define_method(cFastLoc, "unit=", ruby_fast_loc_set_unit, 1);
+  rb_define_method(cFastLoc, "locations", ruby_fast_loc_locations, 0);
+  rb_define_method(cFastLoc, "nearest", ruby_fast_loc_nearest, 2);
+  rb_define_method(cFastLoc, "reset", ruby_fast_loc_reset, 0);
+}

data/ext/test.rb

@@ -0,0 +1,49 @@
+$:.unshift '.'
+require 'fastloc'
+
+10.times do
+
+floc = FastLoc.new(:unit => :miles)
+puts floc.unit
+floc.unit = :kilometers
+puts floc.unit
+floc.unit = :nautical_miles
+puts floc.unit
+floc.unit = :miles
+puts floc.unit
+
+floc.add(39.0566, -76.5352, 1)
+floc.add(39.07, -76.5398, 2)
+floc.add(39.0566, -76.5352, 3)
+floc.add(39.07, -76.5398, 4)
+floc.add(39.0566, -76.5352, 5)
+floc.add(39.07, -76.5398, 6)
+floc.add(39.0566, -76.5352, 7)
+floc.add(39.07, -76.5398, 8)
+floc.add(39.0566, -76.5352, 9)
+floc.add(39.07, -76.5398, 10)
+floc.add(39.0566, -76.5352, 11)
+floc.add(39.07, -76.5398, 12)
+floc.add(39.0566, -76.5352, 13)
+floc.add(39.07, -76.5398, 14)
+floc.add(39.0566, -76.5352, 15)
+floc.add(39.07, -76.5398, 16)
+floc.add(39.0566, -76.5352, 17)
+floc.add(39.07, -76.5398, 18)
+floc.add(39.0566, -76.5352, 19)
+floc.add(39.07, -76.5398, 20)
+
+#puts floc.locations.inspect
+t = Time.now
+n = 1000
+n.times do
+  floc.nearest(39.0735, -76.5654)
+end
+dur = Time.now - t
+rate = n / dur
+puts "processed: #{dur} seconds #{rate} per second with 20 possible"
+
+floc.reset
+floc=nil
+end
+GC.start

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: fast_nearest_latlng
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Todd A. Fisher
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-15 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Locate the nearest location within a set to a given location
+email: todd.fisher@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- ext/fastloc.c
+- ext/extconf.rb
+- ext/test.rb
+- LICENSE
+- README
+has_rdoc: true
+homepage: http://github.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: fast_nearest_latlng
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Nearest lat lng lookup
+test_files: 
+- ext/test.rb