graticule 0.1.1 → 0.1.2

data/CHANGELOG.txt

@@ -1,5 +1,10 @@
 
-0.1.1
+
+0.1.2
+* added "geocode" executable. See "geocode --help" for more information
+* declared dependency on ActiveSupport
+
+0.1.1 (2006-12-16)
 * fixed bug in Yahoo that raised error when street address not returned
 * migrated to Hoe (http://seattlerb.rubyforge.org/hoe/)
 * added Haversine, Spherical and Vincenty distance calculations

data/Manifest.txt

@@ -3,8 +3,10 @@ LICENSE.txt
 Manifest.txt
 README.txt
 Rakefile
+bin/geocode
 init.rb
 lib/graticule.rb
+lib/graticule/cli.rb
 lib/graticule/distance.rb
 lib/graticule/distance/haversine.rb
 lib/graticule/distance/spherical.rb

data/README.txt

@@ -8,3 +8,18 @@ Graticule is a geocoding API for looking up address coordinates.  It supports su
   require 'graticule'
   geocoder = Graticule.service(:google).new "api_key"
   location = geocoder.locate "61 East 9th Street, Holland, MI"
+
+= Distance Calculation
+
+Graticule includes 3 different distance formulas, Spherical (simplest but least accurate), Vincenty (most accurate and most complicated), and Haversine (somewhere inbetween).
+
+  geocoder.locate("Holland, MI").distance_to(geocoder.locate("Chicago, IL"))
+  #=> 101.997458788177
+  
+= Command Line
+
+Graticule includes a command line interface (CLI).
+
+  $ geocode -s yahoo -a yahookey Washington, DC
+  Washington, DC US
+  latitude: 38.895222, longitude: -77.036758

data/Rakefile

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'hoe'
 require File.join(File.dirname(__FILE__), 'lib', 'graticule', 'version.rb')
 
-Hoe.new("graticule", Graticule::Version) do |p|
+Hoe.new("graticule", Graticule::Version::STRING) do |p|
   p.rubyforge_name = "graticule"
   p.author = 'Brandon Keepers'
   p.email = 'brandon@opensoul.org'
@@ -13,4 +13,5 @@ Hoe.new("graticule", Graticule::Version) do |p|
   p.need_zip = true
   p.test_globs = ['test/**/*_test.rb']
   p.changes = p.paragraphs_of('CHANGELOG.txt', 0..1).join("\n\n")
+  p.extra_deps << ['activesupport']
 end

data/bin/geocode

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'geocode' is installed as part of a gem, and
+# this file is here to facilitate running it. 
+#
+
+require 'rubygems'
+version = "> 0"
+if ARGV.size > 0 && ARGV[0][0]==95 && ARGV[0][-1]==95
+  if Gem::Version.correct?(ARGV[0][1..-2])
+    version = ARGV[0][1..-2] 
+    ARGV.shift
+  end
+end
+require_gem 'graticule', version
+
+Graticule::Cli.start

data/lib/graticule.rb

@@ -1,4 +1,6 @@
-$:.unshift(File.dirname(__FILE__))      
+$:.unshift(File.dirname(__FILE__))
+
+require 'active_support'
 
 require 'graticule/location'
 require 'graticule/geocoder'
@@ -12,3 +14,5 @@ require 'graticule/distance'
 require 'graticule/distance/haversine'
 require 'graticule/distance/spherical'
 require 'graticule/distance/vincenty'
+
+require 'graticule/cli'

data/lib/graticule/cli.rb

@@ -0,0 +1,60 @@
+require 'optparse'
+
+module Graticule
+  
+  # A command line interface for geocoding.  From the command line, run:
+  #
+  #   geocode 49423 
+  #
+  # Outputs:
+  #
+  #   # Holland, MI 49423 US
+  #   # latitude: 42.7654, longitude: -86.1085
+  #
+  # == Usage: geocode [options] location
+  # 
+  # Options: 
+  #     -s, --service service            Geocoding service
+  #     -a, --apikey apikey              API key for the selected service
+  #     -h, --help                       Help
+  class Cli
+    
+    def self.start
+      options = { :service => :yahoo, :api_key => 'YahooDemo' }
+      
+      option_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: geocode [options] location"
+        opts.separator ""
+        opts.separator "Options: "
+
+        opts.on("-s service", %w(yahoo google geocoder_us metacarta), "--service service", "Geocoding service") do |service|
+          options[:service] = service
+        end
+        
+        opts.on("-a apikey", "--apikey apikey", "API key for the selected service")
+        
+        opts.on_tail("-h", "--help", "Help") do
+          puts opts
+          exit
+        end
+      end.parse!
+
+      result = Graticule.service(options[:service]).new(options[:api_key]).locate(options[:location])
+      location = (result.is_a?(Array) ? result.first : result)
+      if location
+        puts location.to_s(true)
+      else
+        puts "Location not found"
+      end
+    rescue OptionParser::InvalidArgument => error
+      $stderr.puts error.message
+    rescue OptionParser::InvalidOption => error
+      $stderr.puts error.message
+    rescue Graticule::CredentialsError
+      $stderr.puts "Invalid API key. Pass your #{options[:service]} API key using the -a option. "
+    end
+    
+    
+  end
+end
+

data/lib/graticule/distance.rb

@@ -1,22 +1,27 @@
 module Graticule
   module Distance
+    
     EARTH_RADIUS = { :kilometers => 6378.135, :miles => 3963.1676 }
     # WGS-84 numbers
     EARTH_MAJOR_AXIS_RADIUS = { :kilometers => 6378.137, :miles => 3963.19059 }
     EARTH_MINOR_AXIS_RADIUS = { :kilometers => 6356.7523142, :miles => 3949.90276 }
 
     class DistanceFormula
-      
+      include Math
+      extend Math
+       
       def initialize
         raise NotImplementedError
       end
       
+      # Convert from degrees to radians
       def self.deg2rad(deg)
-      	(deg * Math::PI / 180)
+      	(deg * PI / 180)
       end
 
+      # Convert from radians to degrees
       def self.rad2deg(rad)
-      	(rad * 180 / Math::PI)
+      	(rad * 180 / PI)
       end
 
     end

data/lib/graticule/distance/haversine.rb

@@ -1,22 +1,21 @@
-
 module Graticule
   module Distance
-
     #
-    # Thanks to Chris Veness for distance formulas.
-    #   * http://www.movable-type.co.uk/scripts/LatLong.html
+    # The Haversine Formula works better at small distances than the Spherical Law of Cosines
     #
-    # Distance Measured usign the Haversine Formula
-    # Works better at small distances than the Spherical Law of Cosines
-    # R = earth’s radius (mean radius = 6,371km)
-    # Δlat = lat2− lat1
-    # Δlong = long2− long1
-    # a = sin²(Δlat/2) + cos(lat1).cos(lat2).sin²(Δlong/2)
-    # c = 2.atan2(√a, √(1−a))
-    # d = R.c
+    # Thanks to Chris Veness (http://www.movable-type.co.uk/scripts/LatLong.html)
+    # for distance formulas.
     #
     class Haversine < DistanceFormula
-  
+      
+      # Calculate the distance between two Locations using the Haversine formula
+      #
+      #   Graticule::Distance::Haversine.distance(
+      #     Graticule::Location.new(:latitude => 42.7654, :longitude => -86.1085),
+      #     Graticule::Location.new(:latitude => 41.849838, :longitude => -87.648193)
+      #   )
+      #   #=> 101.061720831836
+      #
       def self.distance(from, to, units = :miles)
         from_longitude  = deg2rad(from.longitude)
         from_latitude   = deg2rad(from.latitude)
@@ -26,40 +25,16 @@ module Graticule
         latitude_delta  = to_latitude - from_latitude
         longitude_delta = to_longitude - from_longitude
 
-        a = Math.sin(latitude_delta/2)**2 + 
-            Math.cos(from_latitude) * 
-            Math.cos(to_latitude) * 
-            Math.sin(longitude_delta/2)**2
+        a = sin(latitude_delta/2)**2 + 
+            cos(from_latitude) * 
+            cos(to_latitude) * 
+            sin(longitude_delta/2)**2
 
-        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+        c = 2 * atan2(sqrt(a), sqrt(1-a))
 
         d = EARTH_RADIUS[units.to_sym] * c
       end
 
-      # # What formula is this?
-      # def self.distance(from, to, units = :miles)
-      #   from_longitude = deg2rad(from.longitude)
-      #   from_latitude = deg2rad(from.latitude)
-      #   to_longitude = deg2rad(to.longitude)
-      #   to_latitude = deg2rad(to.latitude)
-      # 
-      #   Math.acos(
-      #       Math.cos(from_longitude) *
-      #       Math.cos(to_longitude) * 
-      #       Math.cos(from_latitude) * 
-      #       Math.cos(to_latitude) +
-      # 
-      #       Math.cos(from_latitude) *
-      #       Math.sin(from_longitude) *
-      #       Math.cos(to_latitude) *
-      #       Math.sin(to_longitude) +
-      # 
-      #       Math.sin(from_latitude) *
-      #       Math.sin(to_latitude)
-      #   ) * EARTH_RADIUS[units.to_sym]
-      # end
-   
-      
     end
   end
 end

data/lib/graticule/distance/spherical.rb

@@ -2,12 +2,19 @@ module Graticule
   module Distance
 
     #
-    # Distance Measured usign the Spherical Law of Cosines
-    # Simplist though least accurate (earth isn't a perfect sphere)
-    # d = acos(sin(lat1).sin(lat2)+cos(lat1).cos(lat2).cos(long2−long1)).R
+    # The Spherical Law of Cosines is the simplist though least accurate distance
+    # formula (earth isn't a perfect sphere).
     #
     class Spherical < DistanceFormula
 
+      # Calculate the distance between two Locations using the Spherical formula
+      #
+      #   Graticule::Distance::Spherical.distance(
+      #     Graticule::Location.new(:latitude => 42.7654, :longitude => -86.1085),
+      #     Graticule::Location.new(:latitude => 41.849838, :longitude => -87.648193)
+      #   )
+      #   #=> 101.061720831853
+      #
       def self.distance(from, to, units = :miles)
         from_longitude   = deg2rad(from.longitude)
         from_latitude    = deg2rad(from.latitude)
@@ -24,6 +31,21 @@ module Graticule
         ) * EARTH_RADIUS[units.to_sym]
       end
 
+      def self.to_sql(options)
+        options = {
+          :units => :miles,
+          :latitude_column => 'latitude',
+          :longitude_column => 'longitude'
+        }.merge(options)
+        %{(ACOS(
+            SIN(RADIANS(#{options[:latitude]})) *
+            SIN(RADIANS(#{options[:latitude_column]})) +
+            COS(RADIANS(#{options[:latitude]})) *
+            COS(RADIANS(#{options[:latitude_column]})) *
+            COS(RADIANS(#{options[:longitude_column]}) - RADIANS(#{options[:longitude]}))
+          ) * #{Graticule::Distance::EARTH_RADIUS[options[:units].to_sym]})
+        }.gsub("\n", '').squeeze(" ")
+      end
   
     end
   end

data/lib/graticule/distance/vincenty.rb

@@ -2,44 +2,21 @@ module Graticule
   module Distance
 
     #
-    # Thanks to Chris Veness for distance formulas.
-    #   * http://www.movable-type.co.uk/scripts/LatLongVincenty.html
+    # The Vincenty Formula uses an ellipsoidal model of the earth, which is very accurate.
     #
-    # Distance Measured usign the Vincenty Formula
-    # Very accurate, using an accurate ellipsoidal model of the earth
-    # a, b = major & minor semiaxes of the ellipsoid	 
-    # f = flattening (a−b)/a	 
-    # φ1, φ2 = geodetic latitude	 
-    # L = difference in longitude	 
-    # U1 = atan((1−f).tanφ1) (U is ‘reduced latitude’)	 
-    # U2 = atan((1−f).tanφ2)	 
-    # λ = L, λ′ = 2π	 
-    # while abs(λ−λ′) > 10-12 { (i.e. 0.06mm)	 
-    #     	sinσ = √[ (cosU2.sinλ)² + (cosU1.sinU2 − sinU1.cosU2.cosλ)² ]	(14)
-    #  	cosσ = sinU1.sinU2 + cosU1.cosU2.cosλ	(15)
-    #  	σ = atan2(sinσ, cosσ)	(16)
-    #  	sinα = cosU1.cosU2.sinλ / sinσ	(17)
-    #  	cos²α = 1 − sin²α (trig identity; §6)	 
-    #  	cos2σm = cosσ − 2.sinU1.sinU2/cos²α	(18)
-    #  	C = f/16.cos²α.[4+f.(4−3.cos²α)]	(10)
-    #  	λ′ = λ	 
-    #  	λ = L + (1−C).f.sinα.{σ+C.sinσ.[cos2σm+C.cosσ.(−1+2.cos²2σm)]}	(11)
-    # }	 	 
-    # u² = cos²α.(a²−b²)/b²	 
-    # A = 1+u²/16384.{4096+u².[−768+u².(320−175.u²)]}	(3)
-    # B = u²/1024.{256+u².[−128+u².(74−47.u²)]}	(4)
-    # Δσ = B.sinσ.{cos2σm+B/4.[cosσ.(−1+2.cos²2σm) − B/6.cos2σm.(−3+4.sin²σ).(−3+4.cos²2σm)]}	(6)
-    # s = b.A.(σ−Δσ)	(19)
-    # α1 = atan2(cosU2.sinλ, cosU1.sinU2 − sinU1.cosU2.cosλ)	(20)
-    # α2 = atan2(cosU1.sinλ, −sinU1.cosU2 + cosU1.sinU2.cosλ)	(21)
-    # Where:
-    # 
-    # s is the distance (in the same units as a & b)
-    # α1 is the initial bearing, or forward azimuth
-    # α2 is the final bearing (in direction p1→p2)
+    # Thanks to Chris Veness (http://www.movable-type.co.uk/scripts/LatLongVincenty.html)
+    # for distance formulas.
     #
     class Vincenty < DistanceFormula
 
+      # Calculate the distance between two Locations using the Vincenty formula
+      #
+      #   Graticule::Distance::Vincenty.distance(
+      #     Graticule::Location.new(:latitude => 42.7654, :longitude => -86.1085),
+      #     Graticule::Location.new(:latitude => 41.849838, :longitude => -87.648193)
+      #   )
+      #   #=> 101.070118000159
+      #
       def self.distance(from, to, units = :miles)
         from_longitude   = deg2rad(from.longitude)
         from_latitude    = deg2rad(from.latitude)
@@ -51,47 +28,47 @@ module Graticule
 
         f = (earth_major_axis_radius - earth_minor_axis_radius) / earth_major_axis_radius
 
-       l = to_longitude - from_longitude
-       u1 = Math.atan((1-f) * Math.tan(from_latitude))
-       u2 = Math.atan((1-f) * Math.tan(to_latitude))
-       sinU1 = Math.sin(u1)
-       cosU1 = Math.cos(u1)
-       sinU2 = Math.sin(u2)
-       cosU2 = Math.cos(u2)
+        l = to_longitude - from_longitude
+        u1 = atan((1-f) * tan(from_latitude))
+        u2 = atan((1-f) * tan(to_latitude))
+        sin_u1 = sin(u1)
+        cos_u1 = cos(u1)
+        sin_u2 = sin(u2)
+        cos_u2 = cos(u2)
 
-       lambda = l
-       lambdaP = 2*Math::PI
-         iterLimit = 20;
-         while (lambda-lambdaP).abs > 1e-12 && --iterLimit>0
-           sinLambda = Math.sin(lambda)
-           cosLambda = Math.cos(lambda)
-           sinSigma = Math.sqrt((cosU2*sinLambda) * (cosU2*sinLambda) + 
-             (cosU1*sinU2-sinU1*cosU2*cosLambda) * (cosU1*sinU2-sinU1*cosU2*cosLambda))
-           return 0 if sinSigma==0  # co-incident points
-           cosSigma = sinU1*sinU2 + cosU1*cosU2*cosLambda
-           sigma = Math.atan2(sinSigma, cosSigma)
-           sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma
-           cosSqAlpha = 1 - sinAlpha*sinAlpha
-           cos2SigmaM = cosSigma - 2*sinU1*sinU2/cosSqAlpha
+        lambda = l
+        lambda_p = 2 * PI
+        iteration_limit = 20
+        while (lambda-lambda_p).abs > 1e-12 && (iteration_limit -= 1) > 0
+          sin_lambda = sin(lambda)
+          cos_lambda = cos(lambda)
+          sin_sigma = sqrt((cos_u2*sin_lambda) * (cos_u2*sin_lambda) + 
+            (cos_u1*sin_u2-sin_u1*cos_u2*cos_lambda) * (cos_u1*sin_u2-sin_u1*cos_u2*cos_lambda))
+          return 0 if sin_sigma == 0  # co-incident points
+          cos_sigma = sin_u1*sin_u2 + cos_u1*cos_u2*cos_lambda
+          sigma = atan2(sin_sigma, cos_sigma)
+          sin_alpha = cos_u1 * cos_u2 * sin_lambda / sin_sigma
+          cosSqAlpha = 1 - sin_alpha*sin_alpha
+          cos2SigmaM = cos_sigma - 2*sin_u1*sin_u2/cosSqAlpha
 
-           cos2SigmaM = 0 if cos2SigmaM.nan?  # equatorial line: cosSqAlpha=0 (§6)
+          cos2SigmaM = 0 if cos2SigmaM.nan?  # equatorial line: cosSqAlpha=0 (§6)
 
-           c = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha))
-           lambdaP = lambda
-           lambda = l + (1-c) * f * sinAlpha *
-             (sigma + c*sinSigma*(cos2SigmaM+c*cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)))
-         end
-         return NaN if (iterLimit==0)  # formula failed to converge
+          c = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha))
+          lambda_p = lambda
+          lambda = l + (1-c) * f * sin_alpha *
+            (sigma + c*sin_sigma*(cos2SigmaM+c*cos_sigma*(-1+2*cos2SigmaM*cos2SigmaM)))
+       end
+       # formula failed to converge (happens on antipodal points)
+       # We'll call Haversine formula instead.
+       return Haversine.distance(from, to, units) if iteration_limit == 0 
 
-         uSq = cosSqAlpha * (earth_major_axis_radius**2 - earth_minor_axis_radius**2) / (earth_minor_axis_radius**2);
-         bigA = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)));
-         bigB = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)));
-         deltaSigma = bigB*sinSigma*(cos2SigmaM+bigB/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)-
-           bigB/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)));
-         s = earth_minor_axis_radius*bigA*(sigma-deltaSigma);
-
-         #s = s.toFixed(3) # round to 1mm precision
-         return s
+       uSq = cosSqAlpha * (earth_major_axis_radius**2 - earth_minor_axis_radius**2) / (earth_minor_axis_radius**2)
+       a = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)))
+       b = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)))
+       delta_sigma = b*sin_sigma*(cos2SigmaM+b/4*(cos_sigma*(-1+2*cos2SigmaM*cos2SigmaM)-
+         b/6*cos2SigmaM*(-3+4*sin_sigma*sin_sigma)*(-3+4*cos2SigmaM*cos2SigmaM)))
+         
+        earth_minor_axis_radius * a * (sigma-delta_sigma)
       end
   
     end

data/lib/graticule/geocoder.rb

@@ -1,6 +1,12 @@
 
 module Graticule
   
+  # Get a geocoder for the given service
+  #
+  #   geocoder = Graticule.service(:google).new "api_key"
+  #
+  # See the documentation for your specific geocoder for more information
+  #
   def self.service(name)
     self.const_get "#{name}_geocoder".camelize
   end

data/lib/graticule/geocoders/bogus.rb

@@ -1,12 +1,11 @@
-
 module Graticule #:nodoc:
 
   # Bogus geocoder that can be used for test purposes
   class BogusGeocoder < Geocoder
     
     def locate(address)
-      Location.new
+      Location.new :street => address
     end
     
   end
-end
+end

data/lib/graticule/geocoders/geocoder_us.rb

@@ -27,7 +27,7 @@ module Graticule #:nodoc:
       get :address => address
     end
 
-    def parse_response(xml)
+    def parse_response(xml) #:nodoc:
       location = Location.new
       location.street = xml.elements['rdf:RDF/geo:Point/dc:description'].text
 
@@ -37,7 +37,7 @@ module Graticule #:nodoc:
       return location
     end
 
-    def check_error(xml)
+    def check_error(xml) #:nodoc:
       raise AddressError, xml.text if xml.text == 'couldn\'t find this address! sorry'
     end
 

data/lib/graticule/geocoders/google.rb

@@ -44,7 +44,7 @@ module Graticule
     end
 
     # Extracts a Location from +xml+.
-    def parse_response(xml)
+    def parse_response(xml) #:nodoc:
       longitude, latitude, = xml.elements['/kml/Response/Placemark/Point/coordinates'].text.split(',').map { |v| v.to_f }
       Location.new \
         :street => text(xml.elements['/kml/Response/Placemark/AddressDetails/Country/AdministrativeArea/SubAdministrativeArea/Locality/Thoroughfare/ThoroughfareName']),
@@ -58,7 +58,7 @@ module Graticule
     end
 
     # Extracts and raises an error from +xml+, if any.
-    def check_error(xml)
+    def check_error(xml) #:nodoc:
       status ||= xml.elements['/kml/Response/Status/code'].text.to_i
       case status
       when 200 then # ignore, ok
@@ -81,7 +81,7 @@ module Graticule
 
     # Creates a URL from the Hash +params+.  Automatically adds the key and
     # sets the output type to 'xml'.
-    def make_url(params)
+    def make_url(params) #:nodoc:
       params[:key] = @key
       params[:output] = 'xml'
 

data/lib/graticule/geocoders/yahoo.rb

@@ -81,14 +81,14 @@ module Graticule #:nodoc:
     end
 
     # Extracts and raises an error from +xml+, if any.
-    def check_error(xml)
+    def check_error(xml) #:nodoc:
       err = xml.elements['Error']
       raise Error, err.elements['Message'].text if err
     end
 
     # Creates a URL from the Hash +params+.  Automatically adds the appid and
     # sets the output type to 'xml'.
-    def make_url(params)
+    def make_url(params) #:nodoc:
       params[:appid] = @appid
       params[:output] = 'xml'
 

data/lib/graticule/location.rb

@@ -1,5 +1,6 @@
-
 module Graticule
+  
+  # A geographic location
   class Location
     attr_accessor :latitude, :longitude, :street, :city, :state, :zip, :country, :precision, :warning
     
@@ -20,9 +21,26 @@ module Graticule
       end
     end
     
+    # Calculate the distance to another location.  See the various Distance formulas
+    # for more information
     def distance_to(destination, units = :miles, formula = :haversine)
       "Graticule::Distance::#{formula.to_s.titleize}".constantize.distance(self, destination)
     end
     
+    # Where would I be if I dug through the center of the earth?
+    def antipode
+      new_longitude = longitude + (longitude >= 0 ? -180 : 180)
+      Location.new(:latitude => -latitude, :longitude => new_longitude)
+    end
+    alias_method :antipodal_location, :antipode
+    
+    def to_s(coordinates = false)
+      result = ""
+      result << "#{street}\n" if street
+      result << [city, [state, zip, country].compact.join(" ")].compact.join(", ")
+      result << "\nlatitude: #{latitude}, longitude: #{longitude}" if coordinates && [latitude, longitude].any?
+      result
+    end
+    
   end
 end

data/lib/graticule/version.rb

@@ -1,3 +1,9 @@
-module Graticule
-  Version = '0.1.1'
+module Graticule #:nodoc:
+  module Version #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY = 2
+  
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
 end

data/test/unit/graticule/distance_test.rb

@@ -18,13 +18,41 @@ module Graticule
         chicago = Location.new(:latitude => 41.85, :longitude => -87.65)
         
         FORMULAS.each do |formula|
-          assert_in_delta formula.distance(washington_dc, chicago), formula.distance(chicago, washington_dc), 0.1
+          assert_in_delta formula.distance(washington_dc, chicago), formula.distance(chicago, washington_dc), 0.00001
           assert_in_delta 594.820, formula.distance(washington_dc, chicago), 1.0
           assert_in_delta 594.820, formula.distance(washington_dc, chicago, :miles), 1.0
           assert_in_delta 957.275, formula.distance(washington_dc, chicago, :kilometers), 1.0
         end
       end
       
+      def test_distance_between_antipodal_points
+        # The Vincenty formula will be indeterminant with antipodal points.
+        # See http://mathworld.wolfram.com/AntipodalPoints.html
+        washington_dc = Location.new(:latitude => 38.898748, :longitude => -77.037684)
+        chicago = Location.new(:latitude => 41.85, :longitude => -87.65)
+        
+        # First, test the deltas.
+        FORMULAS.each do |formula|
+          assert_in_delta 12450.6582171051, 
+            formula.distance(chicago, chicago.antipodal_location), 1.0
+          assert_in_delta 12450.6582171051, 
+            formula.distance(washington_dc, washington_dc.antipodal_location), 1.0
+          assert_in_delta 12450.6582171051, 
+            formula.distance(chicago, chicago.antipodal_location, :miles), 1.0
+          assert_in_delta 12450.6582171051, 
+            formula.distance(washington_dc, washington_dc.antipodal_location, :miles), 1.0
+          assert_in_delta 20037.50205960391, 
+            formula.distance(chicago, chicago.antipodal_location, :kilometers), 1.0
+          assert_in_delta 20037.5020596039, 
+            formula.distance(washington_dc, washington_dc.antipodal_location, :kilometers), 1.0
+        end
+        
+        # Next, test Vincenty.  Vincenty will use haversine instead of returning NaN on antipodal points
+        assert_equal Haversine.distance(washington_dc, washington_dc.antipodal_location), 
+          Vincenty.distance(washington_dc, washington_dc.antipodal_location)
+        assert_equal Haversine.distance(chicago, chicago.antipodal_location),
+          Vincenty.distance(chicago, chicago.antipodal_location)
+      end
     end
   end
 end

data/test/unit/graticule/location_test.rb

@@ -34,5 +34,18 @@ module Graticule
       end
     end
     
+    def test_antipode
+      washington_dc = Location.new(:latitude => 38.898748, :longitude => -77.037684)
+      chicago = Location.new(:latitude => 41.85, :longitude => -87.65)
+      
+      assert_equal [-38.898748, 102.962316], washington_dc.antipode.coordinates
+      assert_equal [-41.85, 92.35], chicago.antipode.coordinates
+      assert_equal [-41, -180], Graticule::Location.new(:latitude => 41, :longitude => 0).antipode.coordinates
+      assert_equal [-41, 179], Graticule::Location.new(:latitude => 41, :longitude => -1).antipode.coordinates
+      assert_equal [-41, -179], Graticule::Location.new(:latitude => 41, :longitude => 1).antipode.coordinates
+      
+      assert_equal washington_dc.coordinates, washington_dc.antipode.antipode.coordinates
+      assert_equal chicago.coordinates, chicago.antipode.antipode.coordinates
+    end
   end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: graticule
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2006-12-16 00:00:00 -05:00
+  version: 0.1.2
+date: 2007-02-12 00:00:00 -05:00
 summary: API for using all the popular geocoding services.
 require_paths: 
 - lib
@@ -33,8 +33,10 @@ files:
 - Manifest.txt
 - README.txt
 - Rakefile
+- bin/geocode
 - init.rb
 - lib/graticule.rb
+- lib/graticule/cli.rb
 - lib/graticule/distance.rb
 - lib/graticule/distance/haversine.rb
 - lib/graticule/distance/spherical.rb
@@ -84,13 +86,22 @@ rdoc_options: []
 
 extra_rdoc_files: []
 
-executables: []
-
+executables: 
+- geocode
 extensions: []
 
 requirements: []
 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
   version_requirement: 
@@ -98,5 +109,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.6
+        version: 1.1.7
     version: