geo_calc 0.5.3 → 0.6.0

data/Changelog.textile

@@ -0,0 +1,4 @@
+h3. May 24, 2011
+
+* Refactored main GeoCalc (geo calculations) module into smaller parts
+* Using autoload to load most modules

data/README.textile

@@ -16,6 +16,13 @@ From command line, run bundler
 
 @$ bundle@
 
+h2. Objetive
+
+The objective of this library is to act as a base for other geo libraries. 
+
+Please take a look at "geo vectors":https://github.com/kristianmandrup/geo_vectors which builds on _geo calc_ and provides various vector operations on geo points. 
+I also have plans to include _geo calc_ in "mongoid geo":https://github.com/kristianmandrup/mongoid_geo, the geo extension library for _Mongoid 2_. 
+
 h2. Quick start (Usage)
 
 First define the points on the globe you want to work with.

data/VERSION

@@ -1 +1 @@
-0.5.3
+0.6.0

data/geo_calc.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{geo_calc}
-  s.version = "0.5.2"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Kristian Mandrup}]
-  s.date = %q{2011-05-13}
+  s.date = %q{2011-05-23}
   s.description = %q{Geo calculations in ruby and javascript}
   s.email = %q{kmandrup@gmail.com}
   s.extra_rdoc_files = [
@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
     ".rspec",
+    "Changelog.textile",
     "Gemfile",
     "LICENSE.txt",
     "README.textile",
@@ -26,49 +27,56 @@ Gem::Specification.new do |s|
     "VERSION",
     "geo_calc.gemspec",
     "lib/geo_calc.rb",
-    "lib/geo_calc/calculations.rb",
+    "lib/geo_calc/calc.rb",
+    "lib/geo_calc/calc/bearing.rb",
+    "lib/geo_calc/calc/destination.rb",
+    "lib/geo_calc/calc/distance.rb",
+    "lib/geo_calc/calc/intersection.rb",
+    "lib/geo_calc/calc/midpoint.rb",
+    "lib/geo_calc/calc/rhumb.rb",
     "lib/geo_calc/core_ext.rb",
     "lib/geo_calc/geo.rb",
     "lib/geo_calc/geo_point.rb",
-    "lib/geo_calc/js/geo_calc.js",
+    "lib/geo_calc/pretty_print.rb",
     "spec/geo_calc/calculations_spec.rb",
+    "spec/geo_calc/core_ext/array_ext_spec.rb",
+    "spec/geo_calc/core_ext/hash_ext_spec.rb",
+    "spec/geo_calc/core_ext/numeric_geo_ext_spec.rb",
+    "spec/geo_calc/core_ext/string_ext_spec.rb",
     "spec/geo_calc/core_ext_spec.rb",
     "spec/geo_calc/geo_point_spec.rb",
     "spec/geo_calc/geo_spec.rb",
-    "spec/spec_helper.rb"
+    "spec/spec_helper.rb",
+    "vendor/assets/javascript/geo_calc.js"
   ]
   s.homepage = %q{http://github.com/kristianmandrup/geo_calc}
   s.licenses = [%q{MIT}]
   s.require_paths = [%q{lib}]
-  s.rubygems_version = %q{1.8.0}
+  s.rubygems_version = %q{1.8.3}
   s.summary = %q{Geo calculation library}
-  s.test_files = [
-    "spec/geo_calc/calculations_spec.rb",
-    "spec/geo_calc/core_ext_spec.rb",
-    "spec/geo_calc/geo_point_spec.rb",
-    "spec/geo_calc/geo_spec.rb",
-    "spec/spec_helper.rb"
-  ]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<rspec>, [">= 2.5.0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<bundler>, [">= 1"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.5.2"])
       s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<rake>, [">= 0.9"])
     else
       s.add_dependency(%q<rspec>, [">= 2.5.0"])
-      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<bundler>, [">= 1"])
+      s.add_dependency(%q<jeweler>, [">= 1.5.2"])
       s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0.9"])
     end
   else
     s.add_dependency(%q<rspec>, [">= 2.5.0"])
-    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<bundler>, [">= 1"])
+    s.add_dependency(%q<jeweler>, [">= 1.5.2"])
     s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0.9"])
   end
 end
 

data/lib/geo_calc/calc/bearing.rb

@@ -0,0 +1,51 @@
+module GeoCalc::Calc
+  module Bearing
+    def bearing_to point
+      GeoCalc::Calc::Bearing.bearing_to self, point
+    end
+
+    # Returns the (initial) bearing from this point to the supplied point, in degrees
+    #   see http:#williams.best.vwh.net/avform.htm#Crs
+    # 
+    # - Point point: Latitude/longitude of destination point
+    # 
+    # Returns -  Numeric: Initial bearing in degrees from North
+
+    def self.bearing_to base_point, point
+      lat1 = base_point.lat.to_rad
+      lat2 = point.lat.to_rad
+      dlon = (point.lon - base_point.lon).to_rad
+
+      y = Math.sin(dlon) * Math.cos(lat2)
+      x = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dlon)
+      bearing = Math.atan2(y, x)
+
+      (bearing.to_deg + 360) % 360
+    end
+
+    def final_bearing_to point
+      GeoCalc::Calc::Bearing.final_bearing_to self, point
+    end
+
+    # Returns final bearing arriving at supplied destination point from this point; the final bearing 
+    # will differ from the initial bearing by varying degrees according to distance and latitude
+    # 
+    # - GeoPoint point: Latitude/longitude of destination point
+    #
+    # Returns Numeric: Final bearing in degrees from North
+
+    def self.final_bearing_to base_point, point
+      # get initial bearing from supplied point back to this point...
+      lat1 = point.lat.to_rad
+      lat2 = base_point.lat.to_rad
+      dlon = (base_point.lon - point.lon).to_rad
+
+      y = Math.sin(dlon) * Math.cos(lat2)
+      x = Math.cos(lat1)*Math.sin(lat2) - Math.sin(lat1)*Math.cos(lat2)*Math.cos(dlon)
+      bearing = Math.atan2(y, x)
+
+      # ... & reverse it by adding 180°
+      (bearing.to_deg+180) % 360
+    end 
+  end
+end

data/lib/geo_calc/calc/destination.rb

@@ -0,0 +1,30 @@
+module GeoCalc::Calc
+  module Destination
+    def destination_point brng, dist
+      GeoCalc::Calc::Destination.destination_point self, brng, dist
+    end
+
+    # Returns the destination point from this point having travelled the given distance (in km) on the 
+    # given initial bearing (bearing may vary before destination is reached)
+    # 
+    #   see http:#williams.best.vwh.net/avform.htm#LL
+    # 
+    # - Numeric bearing: Initial bearing in degrees
+    # - Numeric dist: Distance in km
+    # Returns GeoPoint: Destination point
+
+    def self.destination_point base_point, brng, dist
+      dist = dist / base_point.radius  # convert dist to angular distance in radians
+      brng = brng.to_rad 
+      lat1 = base_point.lat.to_rad
+      lon1 = base_point.lon.to_rad
+
+      lat2 = Math.asin( Math.sin(lat1) * Math.cos(dist) + Math.cos(lat1) * Math.sin(dist) * Math.cos(brng) )
+      lon2 = lon1 + Math.atan2(Math.sin(brng) * Math.sin(dist) * Math.cos(lat1), Math.cos(dist) - Math.sin(lat1) * Math.sin(lat2))
+
+      lon2 = (lon2 + 3*Math::PI) % (2*Math::PI) - Math::PI  # normalise to -180...+180   
+
+      GeoPoint.new lat2.to_deg, lon2.to_deg
+    end
+  end
+end

data/lib/geo_calc/calc/distance.rb

@@ -0,0 +1,43 @@
+ # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
+ #  Latitude/longitude spherical geodesy formulae & scripts (c) Chris Veness 2002-2010            
+ #   - www.movable-type.co.uk/scripts/latlong.html
+ #                                                                                                
+
+module GeoCalc::Calc
+  module Distance  
+    def distance_to point, precision = 4
+      GeoCalc::Calc::Distance.distance_to self, point, precision
+    end
+
+    # Returns the distance from this point to the supplied point, in km 
+    # (using Haversine formula)
+    # 
+    # from: Haversine formula - R. W. Sinnott, "Virtues of the Haversine",
+    #       Sky and Telescope, vol 68, no 2, 1984
+    # 
+    # GeoPoint point: Latitude/longitude of destination point
+    # - Numeric precision=4: number of significant digits to use for returned value
+    #
+    # Returns - Numeric distance in km between this point and destination point
+  
+    def self.distance_to base_point, point, precision = 4
+      # default 4 sig figs reflects typical 0.3% accuracy of spherical model
+      precision ||= 4
+
+      lat1 = base_point.lat.to_rad
+      lon1 = base_point.lon.to_rad
+
+      lat2 = point.lat.to_rad
+      lon2 = point.lon.to_rad
+
+      dlat = lat2 - lat1
+      dlon = lon2 - lon1
+
+      a = Math.sin(dlat/2) * Math.sin(dlat/2) + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dlon/2) * Math.sin(dlon/2)
+      c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+      d = base_point.radius * c
+      d.round(precision)
+    end
+  end
+end
+

data/lib/geo_calc/calc/intersection.rb

@@ -0,0 +1,72 @@
+module GeoCalc::Calc
+  module Intersection
+    def intersection brng1, p2, brng2
+      GeoCalc::Calc::Intersection.intersection self, brng1, p2, brng2
+    end
+
+    # Returns the point of intersection of two paths defined by point and bearing
+    # 
+    #   see http:#williams.best.vwh.net/avform.htm#Intersection
+    # 
+    # @param   {LatLon} p1: First point
+    # @param   {Number} brng1: Initial bearing from first point
+    # @param   {LatLon} p2: Second point
+    # @param   {Number} brng2: Initial bearing from second point
+    # @returns {LatLon} Destination point (null if no unique intersection defined)
+
+    def self.intersection p1, brng1, p2, brng2
+      lat1 = p1.lat.to_rad
+      lon1 = p1.lon.to_rad
+
+      lat2 = p2.lat.to_rad
+      lon2 = p2.lon.to_rad
+
+      brng13 = brng1.to_rad
+      brng23 = brng2.to_rad
+
+      dlat = lat2-lat1
+      dlon = lon2-lon1;
+
+      dist12 = 2*Math.asin( Math.sqrt( Math.sin(dlat/2)*Math.sin(dlat/2) + Math.cos(lat1)*Math.cos(lat2)*Math.sin(dlon/2)*Math.sin(dlon/2) ) )
+      return nil if dist12 == 0
+
+      # initial/final bearings between points
+      brng_a = begin
+        Math.acos( ( Math.sin(lat2) - Math.sin(lat1)*Math.cos(dist12) ) / ( Math.sin(dist12)*Math.cos(lat1) ) )
+      rescue # protect against rounding
+        0
+      end
+
+      brng_b = Math.acos( ( Math.sin(lat1) - Math.sin(lat2)*Math.cos(dist12) ) / ( Math.sin(dist12)*Math.cos(lat2) ) )
+
+      brng12, brng21 = if Math.sin(lon2-lon1) > 0
+        [brng_a, 2*Math::PI - brng_b] 
+      else
+        [2*Math::PI - brng_a, brng_b]
+      end
+
+      alpha1 = (brng13 - brng12 + Math::PI) % (2*Math::PI) - Math::PI  # angle 2-1-3
+      alpha2 = (brng21 - brng23 + Math::PI) % (2*Math::PI) - Math::PI  # angle 1-2-3
+
+      return nil if (Math.sin(alpha1)==0 && Math.sin(alpha2)==0) # infinite intersections
+      return nil if (Math.sin(alpha1)*Math.sin(alpha2) < 0)    # ambiguous intersection
+
+      # alpha1 = Math.abs(alpha1);
+      # alpha2 = Math.abs(alpha2);
+      # ... Ed Williams takes abs of alpha1/alpha2, but seems to break calculation?
+
+      alpha3 = Math.acos( -Math.cos(alpha1)*Math.cos(alpha2) + Math.sin(alpha1)*Math.sin(alpha2)*Math.cos(dist12) )
+
+      dist13 = Math.atan2( Math.sin(dist12)*Math.sin(alpha1)*Math.sin(alpha2), Math.cos(alpha2)+Math.cos(alpha1)*Math.cos(alpha3) )
+
+      lat3 = Math.asin( Math.sin(lat1)*Math.cos(dist13) + Math.cos(lat1)*Math.sin(dist13)*Math.cos(brng13) )
+
+      dlon13 = Math.atan2( Math.sin(brng13)*Math.sin(dist13)*Math.cos(lat1), Math.cos(dist13)-Math.sin(lat1)*Math.sin(lat3) )
+
+      lon3 = lon1 + dlon13;
+      lon3 = (lon3 + Math::PI) % (2*Math::PI) - Math::PI  # normalise to -180..180º
+
+      GeoPoint.new lat3.to_deg, lon3.to_deg
+    end    
+  end
+end

data/lib/geo_calc/calc/midpoint.rb

@@ -0,0 +1,29 @@
+module GeoCalc::Calc
+  module Midpoint
+    def midpoint_to point
+      GeoCalc::Calc::Midpoint.midpoint_to self, point
+    end
+
+    # Returns the midpoint between this point and the supplied point.
+    #   see http:#mathforum.org/library/drmath/view/51822.html for derivation
+    # 
+    # - GeoPoint point: Latitude/longitude of destination point
+    # Returns GeoPoint: Midpoint between this point and the supplied point
+  
+    def self.midpoint_to base_point, point
+      lat1 = base_point.lat.to_rad
+      lon1 = base_point.lon.to_rad;
+      lat2 = point.lat.to_rad
+      dlon = (point.lon - base_point.lon).to_rad
+
+      bx = Math.cos(lat2) * Math.cos(dlon)
+      by = Math.cos(lat2) * Math.sin(dlon)
+
+      lat3 = Math.atan2(Math.sin(lat1)+Math.sin(lat2), Math.sqrt( (Math.cos(lat1)+bx)*(Math.cos(lat1)+bx) + by*by) )
+
+      lon3 = lon1 + Math.atan2(by, Math.cos(lat1) + bx)
+
+      GeoPoint.new lat3.to_deg, lon3.to_deg
+    end    
+  end
+end

data/lib/geo_calc/calc/rhumb.rb

@@ -0,0 +1,98 @@
+module GeoCalc::Calc
+  module Rhumb
+    def rhumb_distance_to point
+      GeoCalc::Calc::Rhumb.rhumb_distance_to self, point
+    end
+
+    # Returns the distance from this point to the supplied point, in km, travelling along a rhumb line
+    # 
+    #   see http:#williams.best.vwh.net/avform.htm#Rhumb
+    # 
+    # - GeoPoint point: Latitude/longitude of destination point
+    # Returns Numeric: Distance in km between this point and destination point
+
+    def self.rhumb_distance_to base_point, point
+      lat1 = base_point.lat.to_rad
+      lat2 = point.lat.to_rad
+
+      dlat = (point.lat - base_point.lat).to_rad
+      dlon = (point.lon - base_point.lon).abs.to_rad
+
+      dphi = Math.log(Math.tan(lat2/2 + Math::PI/4) / Math.tan(lat1/2 + Math::PI/4))
+
+      q = begin
+        dlat / dphi
+      rescue 
+        Math.cos(lat1) # E-W line gives dPhi=0
+      end
+      
+      # if dlon over 180° take shorter rhumb across 180° meridian:
+      dlon = 2*Math::PI - dlon if (dlon > Math::PI)
+
+      dist = Math.sqrt(dlat*dlat + q*q*dlon*dlon) * base_point.radius; 
+
+      dist.round(4)  # 4 sig figures reflects typical 0.3% accuracy of spherical model
+    end
+
+    def rhumb_bearing_to point
+      GeoCalc::Calc::Rhumb.rhumb_bearing_to self, point
+    end
+    # Returns the bearing from this point to the supplied point along a rhumb line, in degrees
+    # 
+    # - GeoPoint point: Latitude/longitude of destination point
+    # Returns Numeric: Bearing in degrees from North
+
+    def self.rhumb_bearing_to base_point, point
+      lat1 = base_point.lat.to_rad
+      lat2 = point.lat.to_rad
+
+      dlon = (point.lon - base_point.lon).to_rad
+
+      dphi = Math.log(Math.tan(lat2/2+Math::PI/4) / Math.tan(lat1/2+Math::PI/4))
+      if dlon.abs > Math::PI
+        dlon = dlon>0 ? -(2*Math::PI-dlon) : (2*Math::PI+dlon);
+      end
+
+      brng = Math.atan2(dlon, dphi);
+
+      (brng.to_deg+360) % 360
+    end
+
+    def rhumb_destination_point brng, dist
+      GeoCalc::Calc::Rhumb.rhumb_destination_point self, brng, dist
+    end
+    # Returns the destination point from this point having travelled the given distance (in km) on the 
+    # given bearing along a rhumb line
+    # 
+    # @param   {Number} brng: Bearing in degrees from North
+    # @param   {Number} dist: Distance in km
+    # @returns {LatLon} Destination point
+
+    def self.rhumb_destination_point base_point, brng, dist
+      d = dist / base_point.radius  # d = angular distance covered on earth's surface
+      lat1 = base_point.lat.to_rad
+      lon1 = base_point.lon.to_rad
+      brng = brng.to_rad
+
+      lat2 = lat1 + d*Math.cos(brng);
+      dlat = lat2 - lat1;
+      dphi = Math.log(Math.tan(lat2/2+Math::PI/4) / Math.tan(lat1/2+Math::PI/4))
+
+      q = begin
+        dlat / dphi
+      rescue 
+        Math.cos(lat1) # E-W line gives dPhi=0
+      end
+
+      dlon = d * Math.sin(brng) / q
+      # check for some daft bugger going past the pole
+
+      if lat2.abs > Math::PI/2
+        lat2 = lat2>0 ? Math::PI-lat2 : -(Math::PI-lat2)
+      end
+      lon2 = (lon1+dlon+3*Math::PI) % (2*Math::PI) - Math::PI
+
+      GeoPoint.new lat2.to_deg, lon2.to_deg
+    end
+  end
+end

data/lib/geo_calc/calc.rb

@@ -0,0 +1,27 @@
+module GeoCalc
+  autoload :PrettyPrint,  'geo_calc/pretty_print'
+  
+  module Calc
+  end
+end
+
+module GeoCalc::Calc
+  autoload :Bearing,      'geo_calc/calc/bearing'
+  autoload :Destination,  'geo_calc/calc/destination'
+  autoload :Distance,     'geo_calc/calc/distance'
+  autoload :Intersection, 'geo_calc/calc/intersection'
+  autoload :Midpoint,     'geo_calc/calc/midpoint'  
+  autoload :Rhumb,        'geo_calc/calc/rhumb'    
+  
+  module All
+    def self.included base
+      base.send :include, GeoCalc::Calc::Bearing
+      base.send :include, GeoCalc::Calc::Destination
+      base.send :include, GeoCalc::Calc::Distance
+      base.send :include, GeoCalc::Calc::Intersection
+      base.send :include, GeoCalc::Calc::Midpoint
+      base.send :include, GeoCalc::Calc::Rhumb
+      base.send :include, GeoCalc::PrettyPrint
+    end
+  end  
+end

data/lib/geo_calc/core_ext.rb

@@ -36,6 +36,46 @@ module GeoUnits
     alias_method :in_deg,     :to_deg
     alias_method :in_degrees, :to_deg
   end 
+
+  # all degrees between -180 and 180
+  def normalize_lng deg
+    case deg 
+    when -360..-180
+      deg % 180      
+    when -180..0 
+      -180 + (deg % 180) 
+    when 0..180
+      deg
+    when 180..360
+      deg % 180
+    else
+      raise ArgumentError, "Degrees #{deg} out of range, must be between -360 to 360"
+    end
+  end
+
+  # all degrees between -90 and 90
+  def normalize_lat deg
+    case deg 
+    when -360..-270
+      deg % 90      
+    when -270..-180
+      90 - (deg % 90)
+    when -180..-90
+      - (deg % 90)
+    when -90..0 
+      -90 + (deg % 90) 
+    when 0..90
+      deg
+    when 90..180 
+      deg % 90
+    when 180..270 
+      - (deg % 90)
+    when 270..360 
+      - 90 + (deg % 90)
+    else
+      raise ArgumentError, "Degrees #{deg} out of range, must be between -360 to 360"    
+    end 
+  end
   
   def normalize_deg degrees, shift = 0
     (degrees + shift) % 360 
@@ -87,46 +127,63 @@ module NumericGeoExt
   # @returns {String} A string representation of number which contains precision significant digits
   def to_precision precision
     self.round(precision).to_s
-
-    # numb = self.abs  # can't take log of -ve number...
-    # sign = self < 0 ? '-' : '';
-    # 
-    # # can't take log of zero
-    # if (numb == 0) 
-    #   n = '0.' 
-    #   while (precision -= 1) > 0
-    #     n += '0' 
-    #   end 
-    #   return n
-    # end
-    # 
-    # scale = (Math.log(numb) * Math.log10e).ceil # no of digits before decimal
-    # n = (numb * (precision - scale)**10).round.to_s
-    # if (scale > 0)   # add trailing zeros & insert decimal as required
-    #   l = scale - n.length
-    # 
-    #   while (l -= 1) > 0
-    #     n += '0' 
-    #   end
-    # 
-    #   if scale < n.length 
-    #     n = n.slice(0,scale) + '.' + n.slice(scale)
-    #   else # prefix decimal and leading zeros if required
-    #     while (scale += 1) < 0
-    #       n = '0' + n 
-    #     end
-    #     n = '0.' + n
-    #   end 
-    # end
-    # sign + n
   end
   alias_method :to_fixed, :to_precision
 
+  # all degrees between -180 and 180
+  def normalize_lng
+    case self 
+    when -360, 0, 360
+      0
+    when -360..-180
+      self % 180      
+    when -180..0 
+      -180 + (self % 180) 
+    when 0..180
+      self
+    when 180..360
+      self % 180
+    else
+      return (self % 360).normalize_lng if self > 360
+      return (360 - (self % 360)).normalize_lng if self < -360
+      raise ArgumentError, "Degrees #{self} out of range"
+    end
+  end
+
+  # all degrees between -90 and 90
+  def normalize_lat
+    case self 
+    when -360, 0, 360
+      0
+    when -180, 180
+      0
+    when -360..-270
+      self % 90      
+    when -270..-180
+      90 - (self % 90)
+    when -180..-90
+      - (self % 90)
+    when -90..0 
+      -90 + (self % 90) 
+    when 0..90
+      self
+    when 90..180 
+      self % 90
+    when 180..270 
+      - (self % 90)
+    when 270..360 
+      - 90 + (self % 90)
+    else
+      return (self % 360).normalize_lat if self > 360
+      return (360 - (self % 360)).normalize_lat if self < -360
+      raise ArgumentError, "Degrees #{self} out of range"      
+    end
+  end
+
   def normalize_deg shift = 0
     (self + shift) % 360 
   end
-  alias_method :normalize_degrees, :normalize_deg
-  
+  alias_method :normalize_degrees, :normalize_deg  
 end            
 
 module Math
@@ -137,9 +194,12 @@ end
 
 module NumericLatLngExt
   def to_lat 
-    normalize_deg
+    normalize_lat
+  end
+
+  def to_lng 
+    normalize_lng
   end
-  alias_method :to_lng, :to_lat
     
   def is_between? lower, upper
     (lower..upper).cover? self
@@ -247,8 +307,6 @@ class String
   end
 end
 
-
-
 class Fixnum
   include NumericGeoExt 
   include NumericLatLngExt  
@@ -258,4 +316,4 @@ class Float
   include NumericGeoExt   
   include NumericLatLngExt
 end
-  
+

data/lib/geo_calc/geo.rb

@@ -61,7 +61,7 @@ module Geo
   # @returns {String} deg formatted as deg/min/secs according to specified format
   # @throws  {TypeError} deg is an object, perhaps DOM object without .value?
 
-  def to_dms deg, format = :dms, dp = nil
+  def to_dms deg, format = :dms, dp = nil 
     deg = begin
       deg.to_f
     rescue
@@ -128,6 +128,7 @@ module Geo
   # @returns {String} Deg/min/seconds
 
   def to_lat deg, format = :dms, dp = 0
+    deg = deg.normalize_lat
     _lat = to_dms deg, format, dp
     _lat == '' ? '' : _lat[1..-1] + (deg<0 ? 'S' : 'N')  # knock off initial '0' for lat!
   end
@@ -141,7 +142,7 @@ module Geo
   # @returns {String} Deg/min/seconds
 
   def to_lon deg, format = :dms, dp = 0
-    deg = (360 - deg) * -1 if deg % 360 > 180
+    deg = deg.normalize_lng
     lon = to_dms deg, format, dp
     lon == '' ? '' : lon + (deg<0 ? 'W' : 'E')
   end