geohash_int 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f28778ebf764e4d66db4d08634196017c0c3347f
+  data.tar.gz: 2bc80f85ccc6dcc219ef99cc54ba3bc4a55d5262
+SHA512:
+  metadata.gz: 4695278863e53c7ee00b37e4cf3f6779b2fcd971c82eee630f79b319a5e12e18fee1dad57a5956fe1f0bc75f9d39478fbd831859f74632dbcb516999e66dd8dc
+  data.tar.gz: c90453a766b4b77a39a8db3d86ede1599289848dc5691b813c661b4d7fc443dd531e5cd7ec44b62d424975d774778bc011778c64f75edcca846319619b560c49

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+*.so
+*.dylib

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in geohash_int.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Ary Borenszweig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,143 @@
+# GeohashInt
+
+Wraps [geohash-int](https://github.com/yinqiwen/geohash-int)
+(A fast C99 geohash library which only provides int64 as hash result) for Ruby
+using [FFI](https://github.com/ffi/ffi) (this means it is compatible with all
+implementations of Ruby that support FFI, including MRI, JRuby, and Rubinius).
+
+This can be used to build an efficient spatial data index, as explained
+[here](https://github.com/yinqiwen/ardb/wiki/Spatial-Index).
+
+## Explanation
+
+This library turns a coordinate (a latitude and a longitude) into a 64 bits
+integer. To understand what this integer means we need to learn how the Geohash
+algorithm works. Don't worry, it's super simple.
+
+Suppose we want to encode the coordinate with latitude 42.6 and longitude -5.6.
+
+Let's focus on the value 42.6. Latitudes fall in the range -90..90. We split that
+range in half (-90...0, 0..90) and we check in which half the value falls. We'll
+use 0 if it falls in the lower interval and 1 if it falls in the higher interval.
+In this case it's 1. We then do the same but with this new interval (0..90): split
+it (0...45, 45..90) and see in which half it falls. In this case it's 0.
+
+If we stop here, we get the sequence "10".
+
+We then do the same for the longitude, starting with the range -180..180.
+If we repeat the process two times like before, we get the sequence "01".
+
+We then **interleave** the longitude and latitude sequences and we get "0110".
+Interpreting that as a 64 bits integer we get the value 6, and this is the encoded value.
+
+To decode this value 6 we do the reverse process: de-interleave the sequence and
+reconstruct the original numbers. But, in the process we'll lose precision:
+by splitting the initial ranges -90..90 and -180..180 in halves, but only a couple
+of times, we'll know that the original coordinate is anywhere in the range 0..45 for
+latitude and -90..0 for longitude, with its center latitude 22.5 and longitude -45.0
+as an estimation.
+
+We can increase the number of steps we succesively split the original ranges to
+increase the precision. For example, if we do it 10 times we get the sequence
+"01101111111100000100", which is the number 458500. When decode it back, we get
+(42.626953125, -5.44921875) as a result, which is closer to the original value.
+
+The maximum number of steps we can do this for a 64 bits integer is 32,
+because we use 32 bits for the latitude and 32 bits for the longitude.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'geohash_int'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install geohash_int
+
+## Usage
+
+To encode and decode values:
+
+```ruby
+require "geohash_int"
+
+latitude  = 12.34
+longitude = 56.78
+steps     = 10
+
+value = GeohashInt.encode(latitude, longitude, steps)
+
+value # => 825366
+
+result = GeohashInt.decode(value, steps)
+
+# Geohash is lossy
+result.latitude  # => 12.392578125
+result.longitude # => 56.77734375
+
+# Geohash actually encodes a value to a bounding box:
+# the above latitude and longitude are just its center.
+result.min_latitude   # => 12.3046875
+result.max_latitude   # => 12.48046875
+result.min_longitude  # => 56.6015625
+result.max_longitude  # => 56.953125
+```
+
+From an encoded value you get a neighbour or all neighbors:
+
+```ruby
+require "geohash_int"
+
+latitude  = 12.34
+longitude = 56.78
+steps     = 10
+
+value = GeohashInt.encode(latitude, longitude, steps)
+
+neighbor = GeohashInt.get_neighbor(value, GeohashInt::NORTH, steps)
+
+neighbor # => 825367
+
+neighbors = GeohashInt.get_neighbors(value, steps)
+
+neighbors = # => #<struct GeohashInt::Neighbors
+            #       north=825367, east=825372, west=825364, south=825363,
+            #       south_west=825361, south_east=825369,
+            #       north_west=825365, north_east=825373>
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/citrusbyte/ruby-geohash_int.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## About Citrusbyte
+
+![Citrusbyte](http://i.imgur.com/W6eISI3.png)
+
+GeohashInt is lovingly maintained and funded by Citrusbyte.
+Citrusbyte specializes in solving difficult computer science problems for startups and the enterprise.
+
+At Citrusbyte we believe in and support open source software.
+* Check out more of our open source software at Citrusbyte Labs.
+* Learn more about [our work](https://citrusbyte.com/portfolio).
+* [Hire us](https://citrusbyte.com/contact) to work on your project.
+* [Want to join the team?](http://careers.citrusbyte.com)
+
+*Citrusbyte and the Citrusbyte logo are trademarks or registered trademarks of Citrusbyte, LLC.*

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "geohash_int"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/geohash_int/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2013, yinqiwen
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * 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.
+    * Neither the name of the Ardb nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 <COPYRIGHT HOLDER> 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.

data/ext/geohash_int/Rakefile

@@ -0,0 +1,33 @@
+require "rbconfig"
+require "ffi"
+
+task :default => [:build, :clean]
+
+def cmd(string)
+  fail "Command failed: #{string}" unless system(string)
+end
+
+task :build do
+  lib_name = "geohash.#{FFI::Platform::LIBSUFFIX}"
+
+  cc      = ENV['CC'] || RbConfig::CONFIG['CC'] || 'cc'
+  cflags  = "-fexceptions -O -fno-omit-frame-pointer -fno-strict-aliasing -Wall -Wextra"
+  ldflags = "-fexceptions"
+
+  if FFI::Platform.mac?
+    ldflags << " -bundle"
+  elsif FFI::Platform.name =~ /linux/
+    cflags  << " -fPIC"
+    ldflags << " -shared -Wl,-soname,#{lib_name}"
+  else
+    cflags  << " -fPIC"
+    ldflags << " -shared"
+  end
+
+  cmd "#{cc} #{cflags} -o geohash.o -c geohash.c"
+  cmd "#{cc} #{ldflags} -o #{lib_name} geohash.o"
+end
+
+task :clean do
+  cmd "rm geohash.o"
+end

data/ext/geohash_int/geohash.c

@@ -0,0 +1,427 @@
+/*
+ *Copyright (c) 2013-2014, yinqiwen <yinqiwen@gmail.com>
+ *All rights reserved.
+ *
+ *Redistribution and use in source and binary forms, with or without
+ *modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * 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.
+ *  * Neither the name of Redis nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ *THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS
+ *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.
+ */
+#include <stddef.h>
+#include <stdio.h>
+#include <math.h>
+#include "geohash.h"
+
+/**
+ * Hashing works like this:
+ * Divide the world into 4 buckets.  Label each one as such:
+ *  -----------------
+ *  |       |       |
+ *  |       |       |
+ *  | 0,1   | 1,1   |
+ *  -----------------
+ *  |       |       |
+ *  |       |       |
+ *  | 0,0   | 1,0   |
+ *  -----------------
+ */
+
+int geohash_encode(
+        GeoHashRange lat_range, GeoHashRange lon_range,
+        double latitude, double longitude, uint8_t step, GeoHashBits* hash)
+{
+    if (NULL == hash || step > 32 || step == 0)
+    {
+        return -1;
+    }
+    hash->bits = 0;
+    hash->step = step;
+    uint8_t i = 0;
+    if (latitude < lat_range.min || latitude > lat_range.max
+     || longitude < lon_range.min || longitude > lon_range.max)
+    {
+        return -1;
+    }
+
+    for (; i < step; i++)
+    {
+        uint8_t lat_bit, lon_bit;
+        if (lat_range.max - latitude >= latitude - lat_range.min)
+        {
+            lat_bit = 0;
+            lat_range.max = (lat_range.max + lat_range.min) / 2;
+        }
+        else
+        {
+            lat_bit = 1;
+            lat_range.min = (lat_range.max + lat_range.min) / 2;
+        }
+        if (lon_range.max - longitude >= longitude - lon_range.min)
+        {
+            lon_bit = 0;
+            lon_range.max = (lon_range.max + lon_range.min) / 2;
+        }
+        else
+        {
+            lon_bit = 1;
+            lon_range.min = (lon_range.max + lon_range.min) / 2;
+        }
+        hash->bits <<= 1;
+        hash->bits += lon_bit;
+        hash->bits <<= 1;
+        hash->bits += lat_bit;
+    }
+    return 0;
+}
+
+static inline uint8_t get_bit(uint64_t bits, uint8_t pos)
+{
+    return (bits >> pos) & 0x01;
+}
+
+int geohash_decode(
+        GeoHashRange lat_range, GeoHashRange lon_range, GeoHashBits hash, GeoHashArea* area)
+{
+    if (NULL == area)
+    {
+        return -1;
+    }
+    area->hash = hash;
+    uint8_t i = 0;
+    area->latitude.min = lat_range.min;
+    area->latitude.max = lat_range.max;
+    area->longitude.min = lon_range.min;
+    area->longitude.max = lon_range.max;
+    for (; i < hash.step; i++)
+    {
+        uint8_t lat_bit, lon_bit;
+        lon_bit = get_bit(hash.bits, (hash.step - i) * 2 - 1);
+        lat_bit = get_bit(hash.bits, (hash.step - i) * 2 - 2);
+        if (lat_bit == 0)
+        {
+            area->latitude.max = (area->latitude.max + area->latitude.min) / 2;
+        }
+        else
+        {
+            area->latitude.min = (area->latitude.max + area->latitude.min) / 2;
+        }
+        if (lon_bit == 0)
+        {
+            area->longitude.max = (area->longitude.max + area->longitude.min) / 2;
+        }
+        else
+        {
+            area->longitude.min = (area->longitude.max + area->longitude.min) / 2;
+        }
+    }
+    return 0;
+}
+
+static inline uint64_t interleave64(uint32_t xlo, uint32_t ylo)
+{
+    static const uint64_t B[] =
+        { 0x5555555555555555, 0x3333333333333333, 0x0F0F0F0F0F0F0F0F, 0x00FF00FF00FF00FF, 0x0000FFFF0000FFFF };
+    static const unsigned int S[] =
+        { 1, 2, 4, 8, 16 };
+
+    uint64_t x = xlo; // Interleave lower  bits of x and y, so the bits of x
+    uint64_t y = ylo; // are in the even positions and bits from y in the odd; //https://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
+
+    // x and y must initially be less than 2**32.
+
+    x = (x | (x << S[4])) & B[4];
+    y = (y | (y << S[4])) & B[4];
+
+    x = (x | (x << S[3])) & B[3];
+    y = (y | (y << S[3])) & B[3];
+
+    x = (x | (x << S[2])) & B[2];
+    y = (y | (y << S[2])) & B[2];
+
+    x = (x | (x << S[1])) & B[1];
+    y = (y | (y << S[1])) & B[1];
+
+    x = (x | (x << S[0])) & B[0];
+    y = (y | (y << S[0])) & B[0];
+
+    return x | (y << 1);
+}
+
+static inline uint64_t deinterleave64(uint64_t interleaved)
+{
+    static const uint64_t B[] =
+        { 0x5555555555555555, 0x3333333333333333, 0x0F0F0F0F0F0F0F0F, 0x00FF00FF00FF00FF, 0x0000FFFF0000FFFF,
+                0x00000000FFFFFFFF };
+    static const unsigned int S[] =
+        { 0, 1, 2, 4, 8, 16 };
+
+    uint64_t x = interleaved; ///reverse the interleave process (http://stackoverflow.com/questions/4909263/how-to-efficiently-de-interleave-bits-inverse-morton)
+    uint64_t y = interleaved >> 1;
+
+    x = (x | (x >> S[0])) & B[0];
+    y = (y | (y >> S[0])) & B[0];
+
+    x = (x | (x >> S[1])) & B[1];
+    y = (y | (y >> S[1])) & B[1];
+
+    x = (x | (x >> S[2])) & B[2];
+    y = (y | (y >> S[2])) & B[2];
+
+    x = (x | (x >> S[3])) & B[3];
+    y = (y | (y >> S[3])) & B[3];
+
+    x = (x | (x >> S[4])) & B[4];
+    y = (y | (y >> S[4])) & B[4];
+
+    x = (x | (x >> S[5])) & B[5];
+    y = (y | (y >> S[5])) & B[5];
+
+    return x | (y << 32);
+}
+
+int geohash_fast_encode(
+        GeoHashRange lat_range, GeoHashRange lon_range, double latitude,
+        double longitude, uint8_t step,  GeoHashBits* hash)
+{
+    if (NULL == hash || step > 32 || step == 0)
+    {
+        return -1;
+    }
+    hash->bits = 0;
+    hash->step = step;
+    if   (latitude < lat_range.min || latitude > lat_range.max
+      || longitude < lon_range.min || longitude > lon_range.max)
+    {
+        return -1;
+    }
+
+    // The algorithm computes the morton code for the geohash location within
+    // the range this can be done MUCH more efficiently using the following code
+
+    //compute the coordinate in the range 0-1
+    double lat_offset = (latitude - lat_range.min) / (lat_range.max - lat_range.min);
+    double lon_offset = (longitude - lon_range.min) / (lon_range.max - lon_range.min);
+
+    //convert it to fixed point based on the step size
+    lat_offset *= (1LL << step);
+    lon_offset *= (1LL << step);
+
+    uint32_t ilato = (uint32_t) lat_offset;
+    uint32_t ilono = (uint32_t) lon_offset;
+
+    //interleave the bits to create the morton code.  No branching and no bounding
+    hash->bits = interleave64(ilato, ilono);
+    return 0;
+}
+
+int geohash_fast_decode(GeoHashRange lat_range, GeoHashRange lon_range, GeoHashBits hash, GeoHashArea* area)
+{
+    if (NULL == area)
+    {
+        return -1;
+    }
+    area->hash = hash;
+    uint8_t step = hash.step;
+    uint64_t xyhilo = deinterleave64(hash.bits); //decode morton code
+
+    double lat_scale = lat_range.max - lat_range.min;
+    double lon_scale = lon_range.max - lon_range.min;
+
+    uint32_t ilato = xyhilo;        //get back the original integer coordinates
+    uint32_t ilono = xyhilo >> 32;
+
+    //double lat_offset=ilato;
+    //double lon_offset=ilono;
+    //lat_offset /= (1<<step);
+    //lon_offset /= (1<<step);
+
+    //the ldexp call converts the integer to a double,then divides by 2**step to get the 0-1 coordinate, which is then multiplied times scale and added to the min to get the absolute coordinate
+//    area->latitude.min = lat_range.min + ldexp(ilato, -step) * lat_scale;
+//    area->latitude.max = lat_range.min + ldexp(ilato + 1, -step) * lat_scale;
+//    area->longitude.min = lon_range.min + ldexp(ilono, -step) * lon_scale;
+//    area->longitude.max = lon_range.min + ldexp(ilono + 1, -step) * lon_scale;
+
+    /*
+     * much faster than 'ldexp'
+     */
+    area->latitude.min = lat_range.min + (ilato * 1.0 / (1ull << step)) * lat_scale;
+    area->latitude.max = lat_range.min + ((ilato + 1) * 1.0 / (1ull << step)) * lat_scale;
+    area->longitude.min = lon_range.min + (ilono * 1.0 / (1ull << step)) * lon_scale;
+    area->longitude.max = lon_range.min + ((ilono + 1) * 1.0 / (1ull << step)) * lon_scale;
+
+    return 0;
+}
+
+static int geohash_move_x(GeoHashBits* hash, int8_t d)
+{
+    if (d == 0)
+        return 0;
+    uint64_t x = hash->bits & 0xaaaaaaaaaaaaaaaaLL;
+    uint64_t y = hash->bits & 0x5555555555555555LL;
+
+    uint64_t zz = 0x5555555555555555LL >> (64 - hash->step * 2);
+    if (d > 0)
+    {
+        x = x + (zz + 1);
+    }
+    else
+    {
+        x = x | zz;
+        x = x - (zz + 1);
+    }
+    x &= (0xaaaaaaaaaaaaaaaaLL >> (64 - hash->step * 2));
+    hash->bits = (x | y);
+    return 0;
+}
+
+static int geohash_move_y(GeoHashBits* hash, int8_t d)
+{
+    if (d == 0)
+        return 0;
+    uint64_t x = hash->bits & 0xaaaaaaaaaaaaaaaaLL;
+    uint64_t y = hash->bits & 0x5555555555555555LL;
+
+    uint64_t zz = 0xaaaaaaaaaaaaaaaaLL >> (64 - hash->step * 2);
+    if (d > 0)
+    {
+        y = y + (zz + 1);
+    }
+    else
+    {
+        y = y | zz;
+        y = y - (zz + 1);
+    }
+    y &= (0x5555555555555555LL >> (64 - hash->step * 2));
+    hash->bits = (x | y);
+    return 0;
+}
+
+int geohash_get_neighbors(GeoHashBits hash, GeoHashNeighbors* neighbors)
+{
+    geohash_get_neighbor(hash, GEOHASH_NORTH, &neighbors->north);
+    geohash_get_neighbor(hash, GEOHASH_EAST, &neighbors->east);
+    geohash_get_neighbor(hash, GEOHASH_WEST, &neighbors->west);
+    geohash_get_neighbor(hash, GEOHASH_SOUTH, &neighbors->south);
+    geohash_get_neighbor(hash, GEOHASH_SOUTH_WEST, &neighbors->south_west);
+    geohash_get_neighbor(hash, GEOHASH_SOUTH_EAST, &neighbors->south_east);
+    geohash_get_neighbor(hash, GEOHASH_NORT_WEST, &neighbors->north_west);
+    geohash_get_neighbor(hash, GEOHASH_NORT_EAST, &neighbors->north_east);
+    return 0;
+}
+
+int geohash_get_neighbor(GeoHashBits hash, GeoDirection direction, GeoHashBits* neighbor)
+{
+    if (NULL == neighbor)
+    {
+        return -1;
+    }
+    *neighbor = hash;
+    switch (direction)
+    {
+        case GEOHASH_NORTH:
+        {
+            geohash_move_x(neighbor, 0);
+            geohash_move_y(neighbor, 1);
+            break;
+        }
+        case GEOHASH_SOUTH:
+        {
+            geohash_move_x(neighbor, 0);
+            geohash_move_y(neighbor, -1);
+            break;
+        }
+        case GEOHASH_EAST:
+        {
+            geohash_move_x(neighbor, 1);
+            geohash_move_y(neighbor, 0);
+            break;
+        }
+        case GEOHASH_WEST:
+        {
+            geohash_move_x(neighbor, -1);
+            geohash_move_y(neighbor, 0);
+            break;
+        }
+        case GEOHASH_SOUTH_WEST:
+        {
+            geohash_move_x(neighbor, -1);
+            geohash_move_y(neighbor, -1);
+            break;
+        }
+        case GEOHASH_SOUTH_EAST:
+        {
+            geohash_move_x(neighbor, 1);
+            geohash_move_y(neighbor, -1);
+            break;
+        }
+        case GEOHASH_NORT_WEST:
+        {
+            geohash_move_x(neighbor, -1);
+            geohash_move_y(neighbor, 1);
+            break;
+        }
+        case GEOHASH_NORT_EAST:
+        {
+            geohash_move_x(neighbor, 1);
+            geohash_move_y(neighbor, 1);
+            break;
+        }
+        default:
+        {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+GeoHashBits geohash_next_leftbottom(GeoHashBits bits)
+{
+    GeoHashBits newbits = bits;
+    newbits.step++;
+    newbits.bits <<= 2;
+    return newbits;
+}
+GeoHashBits geohash_next_rightbottom(GeoHashBits bits)
+{
+    GeoHashBits newbits = bits;
+    newbits.step++;
+    newbits.bits <<= 2;
+    newbits.bits += 2;
+    return newbits;
+}
+GeoHashBits geohash_next_lefttop(GeoHashBits bits)
+{
+    GeoHashBits newbits = bits;
+    newbits.step++;
+    newbits.bits <<= 2;
+    newbits.bits += 1;
+    return newbits;
+}
+
+GeoHashBits geohash_next_righttop(GeoHashBits bits)
+{
+    GeoHashBits newbits = bits;
+    newbits.step++;
+    newbits.bits <<= 2;
+    newbits.bits += 3;
+    return newbits;
+}

data/ext/geohash_int/geohash.h

@@ -0,0 +1,108 @@
+/*
+ *Copyright (c) 2013-2014, yinqiwen <yinqiwen@gmail.com>
+ *All rights reserved.
+ *
+ *Redistribution and use in source and binary forms, with or without
+ *modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * 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.
+ *  * Neither the name of Redis nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ *THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS
+ *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.
+ */
+
+#ifndef GEOHASH_H_
+#define GEOHASH_H_
+
+#include <stdint.h>
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+
+    typedef enum
+    {
+        GEOHASH_NORTH = 0,
+        GEOHASH_EAST,
+        GEOHASH_WEST,
+        GEOHASH_SOUTH,
+        GEOHASH_SOUTH_WEST,
+        GEOHASH_SOUTH_EAST,
+        GEOHASH_NORT_WEST,
+        GEOHASH_NORT_EAST
+    } GeoDirection;
+
+    typedef struct
+    {
+            uint64_t bits;
+            uint8_t step;
+    } GeoHashBits;
+
+    typedef struct
+    {
+            double max;
+            double min;
+    } GeoHashRange;
+
+    typedef struct
+    {
+            GeoHashBits hash;
+            GeoHashRange latitude;
+            GeoHashRange longitude;
+    } GeoHashArea;
+
+    typedef struct
+    {
+            GeoHashBits north;
+            GeoHashBits east;
+            GeoHashBits west;
+            GeoHashBits south;
+            GeoHashBits north_east;
+            GeoHashBits south_east;
+            GeoHashBits north_west;
+            GeoHashBits south_west;
+    } GeoHashNeighbors;
+
+    /*
+     * 0:success
+     * -1:failed
+     */
+    int geohash_encode(GeoHashRange lat_range, GeoHashRange lon_range, double latitude, double longitude, uint8_t step, GeoHashBits* hash);
+    int geohash_decode(GeoHashRange lat_range, GeoHashRange lon_range, GeoHashBits hash, GeoHashArea* area);
+
+    /*
+     * Fast encode/decode version, more magic in implementation.
+     */
+    int geohash_fast_encode(GeoHashRange lat_range, GeoHashRange lon_range, double latitude, double longitude, uint8_t step, GeoHashBits* hash);
+    int geohash_fast_decode(GeoHashRange lat_range, GeoHashRange lon_range, GeoHashBits hash, GeoHashArea* area);
+
+    int geohash_get_neighbors(GeoHashBits hash, GeoHashNeighbors* neighbors);
+    int geohash_get_neighbor(GeoHashBits hash, GeoDirection direction, GeoHashBits* neighbor);
+
+    GeoHashBits geohash_next_leftbottom(GeoHashBits bits);
+    GeoHashBits geohash_next_rightbottom(GeoHashBits bits);
+    GeoHashBits geohash_next_lefttop(GeoHashBits bits);
+    GeoHashBits geohash_next_righttop(GeoHashBits bits);
+
+
+#if defined(__cplusplus)
+}
+#endif
+#endif /* GEOHASH_H_ */

data/geohash_int.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "geohash_int/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "geohash_int"
+  spec.version       = GeohashInt::VERSION
+  spec.authors       = ["Ary Borenszweig"]
+  spec.email         = ["asterite@gmail.com"]
+
+  spec.summary       = "Fast Geohash for Ruby that yields integers instead of strings"
+  spec.description   = "Wraps geohash-int (https://github.com/yinqiwen/geohash-int, " \
+                       "a fast C99 geohash library which only provides int64 as hash " \
+                       "result) for Ruby using ffi"
+  spec.homepage      = "https://github.com/citrusbyte/ruby-geohash_int"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ['ext/geohash_int/Rakefile']
+
+  spec.add_dependency "ffi", "~> 1.9.18"
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/geohash_int.rb

@@ -0,0 +1,146 @@
+require "geohash_int/version"
+require "geohash_int/ffi"
+
+# The GeohashInt provides methods to encode and decode geographic
+# coordinates using the geohash algorithm, but instead of returning
+# a string, an integer (Fixnum) is returned.
+#
+# See also:
+#  - https://en.wikipedia.org/wiki/Geohash
+#  - https://github.com/yinqiwen/geohash-int
+#  - https://github.com/yinqiwen/ardb/wiki/Spatial-Index
+module GeohashInt
+  module_function
+
+  LAT_RANGE = GeohashInt::FFI::Range.new.tap do |range|
+    range[:min] = -90.0
+    range[:max] =  90.0
+  end # :nodoc:
+
+  LNG_RANGE = GeohashInt::FFI::Range.new.tap do |range|
+    range[:min] = -180.0
+    range[:max] =  180.0
+  end # :nodoc:
+
+  NORTH       = 0
+  EAST        = 1
+  WEST        = 2
+  SOUTH       = 3
+  SOUTH_WEST  = 4
+  SOUTH_EAST  = 5
+  NORTH_WEST  = 6
+  NORTH_EAST  = 7
+
+  # The result of decoding an integer that represents an encoded coordinate.
+  #
+  # In Geohash, encoding a coordinate results in a value that, when decoded,
+  # returns a bounding box. The `latitude` and `longitude` values are taken
+  # as the middle of the bounding box.
+  class BoundingBox < Struct.new(
+    :latitude, :longitude,
+    :min_latitude, :max_latitude,
+    :min_longitude, :max_longitude,
+  ); end
+
+  # Neighbors of an encoded coordinate.
+  class Neighbors < Struct.new(
+    :north, :east, :west, :south,
+    :south_west, :south_east, :north_west, :north_east,
+  ); end
+
+  # Encodes a coordinate by splitting the world map the given number of steps (1..32).
+  #
+  # Returns the encoded value as an integer (Fixnum). To correctly decode this
+  # value back into a coordinate you must pass the same steps to #decode.
+  #
+  # To learn more about the *steps* argument, read this explanation in the Readme
+  # file: https://github.com/citrusbyte/ruby-geohash_int/blob/master/README.md#explanation
+  def encode(latitude, longitude, steps)
+    bits = GeohashInt::FFI::Bits.new
+
+    result = GeohashInt::FFI.geohash_fast_encode(LAT_RANGE, LNG_RANGE,
+                                                 latitude, longitude,
+                                                 steps, bits)
+    if result == 0
+      bits[:bits]
+    else
+      raise ArgumentError.new("Incorrect value for latitude (#{latitude}), " \
+                              "longitude (#{longitude}) or steps (#{steps})")
+    end
+  end
+
+  # Decodes a previously encoded value. The given *steps* must be the same
+  # as the one given in #encode to generate *value*.
+  #
+  # Returns a BoundingBox where the original  coordinate falls
+  # (the Geohash algorithm is lossy), where `latitude` and `longitude` of that
+  # bounding box are its center.
+  def decode(value, steps)
+    bits = new_bits(value, steps)
+    area = GeohashInt::FFI::Area.new
+
+    # This will always return 0 because the only condition for it
+    # returning something else is when area is NULL, but we are
+    # not passing NULL.
+    GeohashInt::FFI.geohash_fast_decode(LAT_RANGE, LNG_RANGE, bits, area)
+
+    lat_range = area[:latitude]
+    lng_range = area[:longitude]
+
+    lat = (lat_range[:max] + lat_range[:min]) / 2
+    lng = (lng_range[:max] + lng_range[:min]) / 2
+
+    BoundingBox.new(
+      lat, lng,
+      lat_range[:min], lat_range[:max],
+      lng_range[:min], lng_range[:max],
+    )
+  end
+
+  # Gets a neighbor of an encoded value.
+  #
+  # - *direction* must be one of this module's constants ( NORTH, EAST, etc. ).
+  # - *steps* must be the same as the one used in #encode to generate *value*.
+  def get_neighbor(value, direction, steps)
+    bits     = new_bits(value, steps)
+    neighbor = GeohashInt::FFI::Bits.new
+
+    result = GeohashInt::FFI.geohash_get_neighbor(bits, direction, neighbor)
+    if result == 0
+      neighbor[:bits]
+    else
+      raise ArgumentError.new("Incorrect value for direction (#{direction})")
+    end
+  end
+
+  # Gets all neighbors of an encoded value.
+  #
+  # - *steps* must be the same as the one used in `encode` to generate *value*.
+  #
+  # Returns a Neighbors instance.
+  def get_neighbors(value, steps)
+    bits      = new_bits(value, steps)
+    neighbors = GeohashInt::FFI::Neighbors.new
+
+    # This function never fails
+    GeohashInt::FFI.geohash_get_neighbors(bits, neighbors)
+
+    Neighbors.new(
+      neighbors[:north     ][:bits],
+      neighbors[:east      ][:bits],
+      neighbors[:west      ][:bits],
+      neighbors[:south     ][:bits],
+      neighbors[:south_west][:bits],
+      neighbors[:south_east][:bits],
+      neighbors[:north_west][:bits],
+      neighbors[:north_east][:bits],
+    )
+  end
+
+  private def new_bits(value, steps)
+    GeohashInt::FFI::Bits.new.tap do |bits|
+      bits[:bits] = value
+      bits[:step] = steps
+    end
+  end
+end

data/lib/geohash_int/ffi.rb

@@ -0,0 +1,42 @@
+require "ffi"
+
+module GeohashInt
+  # :stopdoc:
+  module FFI
+    extend ::FFI::Library
+    ffi_lib File.expand_path("../../../ext/geohash_int/geohash.#{::FFI::Platform::LIBSUFFIX}", __FILE__)
+
+    class Bits < ::FFI::Struct
+      layout :bits, :uint64,
+             :step, :uint8
+    end
+
+    class Range < ::FFI::Struct
+      layout :max, :double,
+             :min, :double
+    end
+
+    class Area < ::FFI::Struct
+      layout :hash,      Bits,
+             :latitude,  Range,
+             :longitude, Range
+    end
+
+    class Neighbors < ::FFI::Struct
+      layout :north,      Bits,
+             :east,       Bits,
+             :west,       Bits,
+             :south,      Bits,
+             :north_east, Bits,
+             :south_east, Bits,
+             :north_west, Bits,
+             :south_west, Bits
+    end
+
+    attach_function :geohash_fast_encode, [Range.val, Range.val, :double, :double, :uint8, Bits.ptr], :int
+    attach_function :geohash_fast_decode, [Range.val, Range.val, Bits.val, Area.ptr], :int
+
+    attach_function :geohash_get_neighbors, [Bits.val, Neighbors.ptr], :int
+    attach_function :geohash_get_neighbor, [Bits.val, :int, Bits.ptr], :int
+  end
+end

data/lib/geohash_int/version.rb

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

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: geohash_int
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ary Borenszweig
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.18
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.18
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Wraps geohash-int (https://github.com/yinqiwen/geohash-int, a fast C99
+  geohash library which only provides int64 as hash result) for Ruby using ffi
+email:
+- asterite@gmail.com
+executables: []
+extensions:
+- ext/geohash_int/Rakefile
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/geohash_int/LICENSE
+- ext/geohash_int/Rakefile
+- ext/geohash_int/geohash.c
+- ext/geohash_int/geohash.h
+- geohash_int.gemspec
+- lib/geohash_int.rb
+- lib/geohash_int/ffi.rb
+- lib/geohash_int/version.rb
+homepage: https://github.com/citrusbyte/ruby-geohash_int
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Fast Geohash for Ruby that yields integers instead of strings
+test_files: []