vincenty 1.0.1

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.1 / 2009-03-03
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/angle.rb
+lib/coordinate.rb
+lib/core_extensions.rb
+lib/latitude.rb
+lib/longitude.rb
+lib/track_and_distance.rb
+lib/vincenty.rb
+test/ts_all.rb
+test/ts_angle.rb
+test/ts_latitude.rb
+test/ts_longitude.rb
+test/ts_vincenty.rb

data/README.txt

@@ -0,0 +1,104 @@
+= Vincenty
+
+* "http://rubyforge.org/projects/vincenty/"
+
+== DESCRIPTION:
+
+* Vincenty wrote an algorithm for calculating the bearing and distance between two coordinates on the earth
+  and an algorithm for finding a second coordinate, given a starting coordinate, bearing and destination.
+  The algorithms model the earth as an ellipsoid, using the WGS-84 model. This is the common GPS model for
+  mapping to latitudes and longitudes.
+
+  This is a Ruby implementation of Vincenty's algorithms, and the Vincenty class includes two methods for 
+  modeling the earth as a sphere. These were added as a reference for testing the Vincenty algorithm, but
+  could be used on their own. 
+
+  The package also makes use of several other classes that may be useful in their own Right. These include
+  class Angle, class Latitude (subclass of Angle), class Longitude (subclass of Angle), 
+  class TrackAndBearing and class coordinate (which class Vincenty is a subclass)
+
+  Angle requires extensions to Numeric and String to provide to_radians (to_r) and to_degrees (to_d). String also includes a to_decimal_degrees(), which converts most string forms of Latitude and Longitude to decimal form. These extensions are included in the package in core_extensions.rb. Float has also been extended to change round to have an optional argument specifying the number of decimal places to round to. This is fully compatible with the Float.round, as the default is to round to 0 decimal places.
+
+*  The Vincenty code is based on the wikipedia presentation of the Vincenty algorithm http://en.wikipedia.org/wiki/Vincenty%27s_formulae .
+*  The algorithm was modified to include changes I found at http://www.movable-type.co.uk/scripts/latlong-vincenty-direct.html.
+*  I also altered the formulae to correctly return the bearing for angles greater than 180. 
+  
+* Vincenty's original publication
+
+** T Vincenty, "Direct and Inverse Solutions of Geodesics on the Ellipsoid with application of nested equations", Survey Review, vol XXII no 176, 1975 http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf
+
+== FEATURES/PROBLEMS:
+
+* None that I yet know of :)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* require 'rubygems'
+
+== INSTALL:
+
+* sudo gem install vincenty
+
+== LICENSE:
+
+Code unique to this implementation of Vincentys algrithm is distributed under the Ruby License.
+
+Copyright (c) 2009 FIX
+
+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) rename any non-standard executables so the names do not conflict
+  with standard executables, which must also be provided.
+
+     d) make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or executable
+   form, provided that you do at least ONE of the following:
+
+     a) distribute the executables 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 executables 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).  But some files in the distribution
+   are not written by the author, so that they are not under this terms.
+
+   They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+   files under the ./missing directory.  See each file for the copying
+   condition.
+
+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/Rakefile

@@ -0,0 +1,15 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require 'lib/vincenty.rb'
+
+
+Hoe.new('vincenty', Vincenty::VERSION) do |s|
+  s.rubyforge_name = "vincenty" 
+  s.developer( "Rob Burrowes","rob@burrowes.org")
+  #s.url = "http://rubyforge.org/projects/vincenty/" 
+  #s.summary = "Vincenty Algorithm for Distance, Bearing between Map Coordinates." 
+  #s.description = s.paragraphs_of('README.txt', 1..4).join("\n\n")
+end
+

data/lib/angle.rb

@@ -0,0 +1,357 @@
+#Class Angle is a utility class that allows 
+# * Angle arithmetic
+# * Angle comparison
+# * Conversion to and from degrees and radians
+# * Conversion to string as radians or DMS format
+
+require 'core_extensions.rb'
+
+class Angle
+  include Comparable
+  
+  #Provides test for Module Comparable
+  def <=>(v)
+    if v.class == Angle
+      @value <=> v.value
+    else 
+      @value <=> v
+    end
+  end
+
+  attr_accessor :value #stored in radians
+  
+  #v may be anything that has a to_f and to_radians. The Default for v is degrees.
+  #if radians == true then v is in radians, not degrees.
+  def initialize(v=0, radians=false)
+    #assumes that we are getting a value in degrees.
+    if radians
+      @value = v.to_f #works for String, Fixed, other Angles and for Float.
+    else
+      if v.class == Array
+        @value = self.class.decimal_deg(*v).to_radians #Wild assumption that the array is deg,min,sec.
+      else
+        @value = v.to_radians #we have a String and Numeric class version of this. Another Angle will work too.
+      end
+    end
+  end
+  
+  #Class level function that converts an array of up to 4 values into decimal degrees.
+  #a[0..3] is degrees, minutes, seconds, direction. Dircection is one of 'N', 'S', 'E', 'W'.
+  #nil values in the array are set to 0
+  #if the a.length < 4,t then a is extended to be length 4 with 0
+  #A 0 as the direction has no effect on the sign of the result
+  #Returns: signed decimal degress.
+  def self.decimal_deg(*a)
+    (0..3).each { |x|  a[x] = 0 if a[x] == nil } #convert nil arguments to 0 and ensure 4 values.
+    s = { 'N'=>1, 'S'=>-1, 'E'=>1, 'W'=>-1, 0=>1 }
+    a[0].sign * (a[0].abs + a[1]/60.0 + a[2]/3600.0) * s[a[3]]
+  end
+  
+  #Class level utility function to return the value as deg,min,sec
+  #Assumes decimal degress unless radians == true
+  #returns an array of signed deg, min, sec.
+  def self.dms(v, radians = false)
+    v = v.to_d if radians
+    deg = v.floor
+    min = ((v-@deg)*60).floor
+    sec = ((v-@deg-min/60.0)*3600.0) 
+    
+    if v < 0 &&  deg == 0
+      if min == 0
+        sec = -sec
+      else
+        min = -min 
+      end
+    end
+    return deg,min,sec
+  end
+     
+  #Class level function equivalent to Angle.new(r, true)
+  #Returns: new Angle
+  def self.radians(r=0) #passed in radians.
+    self.new(r.to_f, true) #Nb. self is Angle, be we don't Angle.new, as we want subclasses to return their class, not Angle.
+  end
+  
+  #Class level function equivalent to Angle.new(d, false) or just Angle.new(d)
+  #Returns: new Angle
+  def self.degrees(d=0) #passed in degrees.
+    self.new(d.to_radians, true)
+  end
+    
+  #unary +
+  #Returns: new Angle
+  def +@
+    self.class.radians(@value) #Nb. Not Angle.new, as we want subclasses to return their class, not Angle.
+  end
+  
+  #Unary -
+  #Returns: new Angle
+  def -@
+    self.class.radians(-@value)
+  end
+  
+  #Returns :new Angle
+  def +(v)
+    self.class.radians(@value + v)
+  end
+  
+  #Returns: new Angle
+  def -(v)
+    self.class.radians(@value - v)
+  end
+    
+  #Returns :new Angle
+  def *(v)
+    self.class.radians(@value * v)
+  end
+  
+  #Returns: new Angle
+  def **(v)
+    self.class.radians(@value ** v)
+  end
+  
+  #Returns: new Angle
+  def /(v)
+    self.class.radians(@value / v)
+  end
+  
+  #Returns: new Angle
+  def %(v)
+    self.class.radians(@value % v)
+  end
+    
+  #Returns: angle in degrees
+  def to_degrees
+    @value.to_degrees
+  end
+ 
+  alias to_d to_degrees
+  
+  #Returns: angle in radians
+  def to_radians
+    @value
+  end
+
+  alias to_r to_radians
+  
+  #Returns: [deg,min,sec]
+  #Nb. * That min will be negative if the angle is negative and deg == 0
+  #    * That sec will be negative if the angle is negative and deg == 0 && min == 0
+  def to_dms 
+    d = to_degrees.abs
+    deg = d.floor
+    min = ((d-deg)*60).floor
+    sec = ((d-deg-min/60.0)*3600.0) 
+    
+    if @value < 0
+      if deg == 0
+        if min == 0
+          sec = -sec
+        else
+          min = -min 
+        end
+      else
+        deg = -deg
+      end
+    end
+    
+    return deg, min, sec
+  end
+  
+  #Returns: the angle in radians as a float (equivalent to to_radians)
+  alias to_f to_radians
+  
+  #Returns the angle truncated to an integer, in radians.
+  def to_i
+    to_radians.to_i
+  end
+  
+  alias to_int to_i
+  
+  def coerce(v)
+    [Float(v), @value]
+  end
+  
+  #Returns: the sign of the angle. 1 for positive, -1 for negative.
+  def sign
+    @value.sign
+  end
+  
+  #Returns: the absolute value of the angle in radians
+  def abs
+    @value.abs
+  end
+  
+  #Returns: angle as compass bearing in radians.
+  #Compass bearings are clockwise, Math angles are counter clockwise.
+  def to_bearing
+    self.class.new(Math::PI * 2 - @value,true)
+  end
+  
+  #Returns: the reverse angle in radians. i.e. angle + PI (or angle + 180 degrees)
+  def reverse
+    if (v = @value + Math::PI) > Math::PI * 2
+      v -= Math::PI * 2
+    end
+    return self.class.new(v,true)
+  end
+  
+  
+  #Returns: angle in radians as a string.
+  def to_s(fmt = nil)
+    return to_radians.to_s if(fmt == nil)
+    return strf(fmt)
+  end
+  
+  #formated output of the angle.
+  #The default format is a signed deg°minutes′seconds″ with leading 0's in the minutes and seconds and 4 decimal places for seconds.
+  #formats are:
+  # * %wd output the degrees as an integer.
+  # **   where w is 0, 1, 2 or 3 and represents the field width. 
+  # *** 1 is the default, which indicates that at least 1 digit is displayed
+  # *** 2 indicates that at least 2 digits are displayed. 1 to 9 will be displayed as 01° to 09°
+  # *** 3 indicates that at least 4 digits are displayed. 10 to 99 will be displayed as 010° to 099°
+  #
+  # * %w.pD outputs degrees as a float.
+  # ** p is the number of decimal places.
+  #
+  # * %wm output minutes as an integer.
+  # ** where the width w is 0, 1 , 2 with similar meaning to %d. p is again the number of decimal places.
+  #
+  # * %w.pM outputs minutes as a float .e.g. 01.125′.
+  # ** p is the number of decimal places.
+  #
+  # * %wW outputs secs/60 as a float without the leading '0.'. 
+  #       Used with %m like this %2m′%4W , to get minute marker before the decimal places. 
+  #       e.g. -37°01′.1167 rather than -37°01.1167′
+  # ** p is the number of decimal places.
+  #
+  # * %w.ps output seconds as a float.
+  # ** where the width w is 1 , 2 with similar meaning to %d. p is again the number of decimal places.
+  #
+  # * %N outputs N if the angle is positive and S if the angle is negative.
+  #
+  # * %E outputs E if the angle is positive and W if the angle is negative.
+  #
+  # * %r outputs Radians
+  #
+  # * %% outputs %
+  #
+  # Other strings in the format are printed as is.
+  def strf(fmt="%d°%2m′%2.4s″")
+    tokens = fmt.scan(/%[0-9\.]*[%dmsDMNErW]|[^%]*/)
+    have_dir = have_dms = false
+    tokens.collect! do |t|
+      if t[0,1] == '%' #format
+        had_dot = false
+        decimals = -1
+        width = -1
+        format = nil
+        t[1..-1].scan(/[0-9]+|\.|[0-9]+|[%dmsDMNErW]/) do |t2|
+          case t2
+            when  /[0-9]+/
+              if had_dot
+                decimals = t2.to_i
+              else
+                width = t2.to_i
+              end
+            when '%'
+              format = t2
+            when /[dmsMwW]/
+              have_dms = true
+              format = t2
+            when /[NE]/
+              have_dir = true
+              format = t2
+            when '.' 
+              had_dot = true
+            when /[Dr]/
+              format = t2
+            else
+              raise "unknown format character '#{t2}'" #shouldn't be able to get here.
+          end
+        end
+        [:format, width, decimals, format]
+      else
+        [:filler, t]
+      end
+    end
+
+    deg,min,sec = to_dms if have_dms
+
+    s = ""
+    tokens.each do |t|
+      if(t[0] == :format)
+        case t[3]
+        when '%'
+          s += '%'
+        when 'd'
+          s += s_int(deg, t[1], have_dir)
+        when 'D'
+          s += s_float(@value.to_d, t[1], t[2], have_dir)
+        when 'm'
+          s += s_int(min, t[1], have_dir)
+        when 'M'
+          s += s_float(min + sec/60, t[1], t[2], have_dir)
+        when 'W'
+          s += s_only_places(sec/60,  t[1])
+        when 's'
+          s += s_float(sec, t[1], t[2], have_dir)
+        when 'r'
+          s += s_float(@value, t[1], t[2], have_dir)
+        when 'N'
+          s +=  (@value < 0 ? 'S' : 'N')
+        when 'E'
+          s += (@value < 0 ? 'W' : 'E')
+        end
+      else
+        s += t[1] #the fillers.
+      end
+    end
+    
+    return s
+  end
+  
+  private 
+  def s_places(v, places)
+    if places != -1
+      dec_p = (v * 10 ** places).round
+      f = ".%0#{places > 0 ? places : ''}d"
+      f % dec_p
+    else
+      '.' + v_dec.to_s[2..-1] 
+    end
+  end
+
+  def s_only_places(v, places)
+    v_int, v_dec = v.abs.divmod(1)
+    s_places(v_dec, places)
+  end
+
+  #Prints fixed width decimal portion with leading 0s to get at least the width specified
+  #Prints the number of places after the decimal point rounded to places places.
+  #-1 width means no width format
+  #-1 places means print all decimal places.
+  #abs means print the absolute value.
+  def s_float(v, width, places, abs)
+    v_int, v_dec = v.abs.divmod(1)
+    f = "%0#{width > 0 ? width : ''}d"
+    s = (abs == false && v.sign == -1) ? '-' : ''  #catch the case of -0
+    s += f % v.abs + s_places(v_dec, places)
+  end
+
+  def s_int(v, width, abs)
+    f = "%0#{width > 0 ? width : ''}d"
+    s = (abs == false && v.sign == -1) ? '-' : ''  #catch the case of -0
+    s += f % v.abs
+  end
+end
+
+
+
+
+
+
+
+
+

data/lib/coordinate.rb

@@ -0,0 +1,29 @@
+#Holds both latitude and longitude, and the altitude at that point
+
+require 'angle.rb'
+
+class Coordinate
+  attr_accessor :latitude, :longitude, :altitude
+  #latitude and longitude can be Strings or Numeric, or anything else with to_radians and to_f
+  #latitude and longitude are in degrees unless radians == true
+  def initialize(latitude=0, longitude=0, altitude=0, radians = false)
+    @latitude = Latitude.new(latitude,radians)
+    @longitude = Longitude.new(longitude,radians)
+    @altitude = altitude.to_f
+  end
+  
+  #Returns: Latitude longitude and altitude as a single string.
+  def to_s
+    "#{@latitude.to_s }  #{@longitude.to_s} #{@altitude}m"
+  end
+  
+  def to_ary
+    [ @latitude, @longitude, @altitude ]
+  end
+  
+  alias to_a to_ary
+  
+  def to_hash
+    { :latitude => @latitude, :longitude => @longitude, :altitude => @altitude }
+  end
+end

data/lib/core_extensions.rb

@@ -0,0 +1,89 @@
+require 'scanf'
+
+#Extends Numeric, hence Fixed & Float to_r & to_d
+#Also adds in sign.
+class Numeric
+  #Convert Radians to Degrees
+  #if optional argument mod == true, then applies % 360
+  #Returns: degrees
+  def to_degrees(mod=false) 
+    if mod 
+      (self * 180  / Math::PI) % 360
+    else 
+      self * 180  / Math::PI 
+    end
+  end
+  #Converts degrees to Radians
+  #if optional argument mod == true, then applies % Math::PI
+  #Returns: radians
+  def to_radians(mod=false)
+    if mod 
+      (self * Math::PI / 180) % Math::PI
+    else 
+      self * Math::PI / 180
+    end
+  end
+  
+  alias to_r to_radians
+  alias to_d to_degrees
+  
+  #Returns: 1 if number is positive, -1 if negative.
+  def sign
+    self < 0 ? -1 : 1
+  end
+    
+end
+
+#Alters round method to have an optional number of decimal places.
+class Float
+  alias round0 round
+  #Compatible Replacement for Float.round
+  #Optional argument n is the number of decimal places to round to.
+  #Returns: float rounded to n decimal places.
+  def round(n = 0)
+    m = 10.0**n
+   (self *  m).round0 / m
+  end
+end
+
+#Extends String to to_dec_degrees, add to_r and to_d
+class String
+  #string expected to be degrees, returns decimal degrees.
+  #common forms are S37°01′7.5″, 37°01′7.5″S , -37°01′7.5″, -37° 1.512′. -37.01875°, 37°01′.512S, S37°01′.512, ...
+  #Returns: angle in decimal degrees
+  def to_dec_degrees 
+    #reorder 37°01′.512S, S37°01′.512 into 37°01.512′S, S37°01.512′ respectively
+    s = self.gsub(/([0-9])([′'])\.([0-9]+)/, '\1.\3\2')
+    #add in minutes and seconds to get 3 values 'deg 0 0'from  S37°, 37°S
+    s.gsub!(/^([^0-9\.\-]*)([0-9\-\.]+)([^0-9\-\.]*)$/, '\1\2\3 0 0\5')
+    #add in seconds get 3 values 'deg min 0' from  S37°1.512′,  37°1.512′S
+    s.gsub!(/^([^0-9\.\-]*)([0-9\-\.]+)([^0-9\-\.]+)([0-9\-\.]+)([^0-9\-\.]*)$/, '\1\2\3\4 0\5')
+    
+    #look for anything of the form S37°01′7.5″, S37°1.512′, S37.01875°, ...
+    s.scanf("%[NSEW]%f%[^0-9-]%f%[^0-9-]%f") do |direction, deg, sep1, min, sep2, sec|
+      return Angle.decimal_deg( deg,  min,  sec,  direction)
+    end
+    
+    #look for anything of the form 37°01′7.5″S , -37°01′7.5″, -37° 1.512′. -37.01875°, ...
+    s.scanf("%f%[^0-9-]%f%[^0-9-]%f%[^NSEW]%[NSEW]") do |deg, sep1, min, sep2, sec, sep3, direction|
+      return Angle.decimal_deg( deg,  min,  sec,  direction)
+    end
+  end
+  
+  #Convert Radians to Degrees
+  #if optional argument mod == true, then applies % 360
+  #Returns: degrees
+  def to_degrees(mod=false) #string expected to be radians, returns degrees
+    self.to_f.to_degrees(mod)
+  end
+  
+  #Converts string degrees to to_decimal_degrees, then to Radians
+  #if optional argument mod == true, then applies % Math::PI
+  #Returns: radians
+  def to_radians(mod=false) #string expected to be degrees, returns radians
+    self.to_dec_degrees.to_radians(mod)
+  end
+  
+  alias to_r to_radians
+  alias to_d to_degrees
+end

data/lib/latitude.rb

@@ -0,0 +1,42 @@
+#Subclass of Angle to add in special treatment of to_d, to_r , to_s
+
+require 'angle.rb'
+
+class Latitude < Angle
+  #Latitude degrees are between -90 and 90, South to North
+  #Returns angle as degrees in range -90 and 90
+  def to_degrees
+    #longitude's are -180 to 180 for west to east
+    degrees = super
+    case
+    when degrees > 270 : -(360 - degrees)
+    when degrees > 180 : 180 - degrees
+    when degrees > 90 : 180 - degrees
+    when degrees < -90 : 180 - degrees
+    else degrees
+    end
+  end
+  
+  #Latitude degrees are between -PI and PI, South to North
+  #Returns: angle as degrees in range -PI and PI
+  def to_radians
+    #longitude's are -180 to 180 for west to east
+    case
+    when @value > 3*Math::PI/2 :  @value - Math::PI * 2
+    when @value > Math::PI : Math::PI - @value
+    when @value > Math::PI/2 : Math::PI - @value
+    when @value < -Math::PI/2 : -Math::PI - @value
+    else @value
+    end
+  end
+
+  #Returns: angle as string in degrees minutes seconds direction.
+  #A South angle is negative, North is Positive.
+  def to_s(fmt='%2d°%2m′%2.4s″%N')
+      super(fmt)
+  end
+  
+  alias to_r to_radians
+  alias to_d to_degrees
+
+end

data/lib/longitude.rb

@@ -0,0 +1,34 @@
+#Subclass of Angle to add in special treatment of to_d, to_r and to_s
+
+require 'angle.rb'
+
+class Longitude < Angle
+  #Longitude degrees are between -180 and 180 West to East
+  #Returns angle as degrees in range -180 and 180
+  def to_degrees
+    degrees = super
+    case
+      when degrees > 180 : degrees - 360
+      else degrees
+    end
+  end
+  
+  #Longitude degrees are between -2PI and 2PI, West to East
+  #Returns: angle as degrees in range -2PI and 2PI
+  def to_radians
+    case
+      when @value > Math::PI : @value - 2 * Math::PI
+      else @value
+    end
+  end
+  
+  #Returns: angle as string in degrees minutes seconds direction.
+  #A West angle is negative, East is Positive.
+  def to_s(fmt='%3d°%2m′%2.4s″%E')
+    super(fmt)
+  end
+  
+  alias to_r to_radians
+  alias to_d to_degrees
+  
+end

data/lib/track_and_distance.rb

@@ -0,0 +1,26 @@
+#Holds a bearing and distance
+
+require 'angle.rb'
+
+class TrackAndDistance
+    attr_accessor :bearing, :distance
+    #Bearing is in degrees unless radians == true.
+    #Bearing can be a String or Numeric or any object with to_radians and to_f
+    def initialize(bearing, distance, radians=false)
+      @bearing = Angle.new(bearing, radians)
+      @distance = distance
+    end
+    
+    #Returns: Bearing angle and distance in a string.
+    def to_s
+      "#{@bearing.to_d.round(4)} #{distance.round(4)}m"
+    end
+
+    def to_ary
+      [ @bearing, @distance ]
+    end
+    
+    def to_hash
+      { :bearing => @bearing, :distance => @distance }
+    end
+end

data/lib/vincenty.rb

@@ -0,0 +1,187 @@
+#Vincenty's algorithms for finding the bearing and distance between two coordinates and
+#for finding the latitude and longitude, given a start coordinate, distance and bearing.
+#
+# Coded from formulae from Wikipedia http://en.wikipedia.org/wiki/Vincenty%27s_formulae
+# Modified to incorporate corrections to formulae as found in script on http://www.movable-type.co.uk/scripts/LatLongVincenty.html
+# Added my Modification of the distanceAndAngle formulae to correct the compass bearing.
+require 'core_extensions.rb'
+require 'angle.rb'
+require 'latitude.rb'
+require 'longitude.rb'
+require 'track_and_distance.rb'
+require 'coordinate.rb'
+
+class Vincenty < Coordinate
+  VERSION = '1.0.1'
+  #Great Circle formulae  http://en.wikipedia.org/wiki/Great-circle_distance
+  #Reference calculation for testing, assumes the earth is a sphere, which it isn't. 
+  #This gives us an approximation to verify Vincenty algorithm.
+  #Takes: argument p2 is target coordinate that we want the bearing to.
+  #Returns: TrackAndDistance object with the compass bearing and distance in meters to P2
+  def sphericalDistanceAndAngle( p2 ) 
+    a = 6378137 #equatorial radius in meters     (±2 m) 
+    b = 6356752.31424518 #polar radius in meters
+    r = (a+b)/2 #average diametre as a rough estimate for our tests.
+    
+    sin_lat1 = Math.sin(@latitude.to_r)
+    sin_lat2 = Math.sin(p2.latitude.to_r)
+    cos_lat1 = Math.cos(@latitude.to_r)
+    atan1_2 = Math.atan(1) * 2
+    t1 = cos_lat1 * Math.cos(p2.latitude.to_r) * ( Math.cos(@longitude.to_r - p2.longitude.to_r) ) + sin_lat1 * sin_lat2 
+    angular_distance = Math.atan(-t1/Math.sqrt(-t1 * t1 +1)) + atan1_2 #central angle in radians so we can calculate the arc length.
+
+    t2 = (sin_lat2 - sin_lat1 * Math.cos(angular_distance)) / (cos_lat1 * Math.sin(angular_distance))
+    if(Math.sin(p2.longitude.to_r - @longitude.to_r) < 0)
+      bearing =  2 * Math::PI - (Math.atan(-t2 / Math.sqrt(-t2 * t2 + 1)) + atan1_2) #Compass Bearing in radians (clockwise)
+    else
+      bearing = Math.atan(-t2 / Math.sqrt(-t2 * t2 + 1)) + atan1_2 #Compass Bearing in radians (clockwise)
+    end
+
+    #Note that the bearing is a compass angle. That is angles are positive clockwise. 
+    return TrackAndDistance.new(bearing, angular_distance * r, true)
+  end
+
+  #Vincenty's algorithm for finding bearing and distance between to coordinates.
+  #Assumes earth is a WGS-84 Ellipsod.
+  #Takes: argument p2 is target coordinate that we want the bearing to.
+  #Returns: TrackAndDistance object with the compass bearing and distance in meters to P2
+  def distanceAndAngle( p2 )
+    # a, b = major & minor semiaxes of the ellipsoid
+    a = 6378137 #equatorial radius in meters     (±2 m) 
+    b = 6356752.31424518 #polar radius in meters
+    f = (a-b)/a #  flattening 
+   
+     lat1 = @latitude.to_r
+     lon1 = @longitude.to_r
+     lat2 = p2.latitude.to_r
+     lon2 = p2.longitude.to_r
+     lat1 = lat1.sign * (Math::PI/2-(1e-10)) if (Math::PI/2-lat1.abs).abs < 1.0e-10
+     lat2 = lat2.sign * (Math::PI/2-(1e-10)) if (Math::PI/2-lat2.abs).abs < 1.0e-10
+
+    #  lat1, lat2 = geodetic latitude
+    
+      l = (lon2 - lon1).abs #difference in longitude
+      l = 2*Math::PI - l if l > Math::PI
+      u1 = Math.atan( ( 1 - f) * Math.tan( lat1 ) ) #U is ‘reduced latitude’
+      u2 = Math.atan( ( 1 - f) *  Math.tan( lat2 ) )
+      sin_u1 = Math.sin(u1)
+      cos_u1 = Math.cos(u1)
+      sin_u2 = Math.sin(u2)
+      cos_u2 = Math.cos(u2)
+      
+      lambda_v = l
+      lambda_dash =  Math::PI * 2
+      while( (lambda_v - lambda_dash).abs > 1.0e-12   ) #i.e. 0.06 mm error
+        sin_lambda_v = Math.sin(lambda_v)
+        cos_lambda_v = Math.cos(lambda_v)
+       	sin_sigma = Math.sqrt( ( cos_u2 * sin_lambda_v ) ** 2 + ( cos_u1 * sin_u2 - sin_u1 * cos_u2 * cos_lambda_v ) ** 2 )
+    	  cos_sigma = sin_u1 * sin_u2 + cos_u1 * cos_u2 * cos_lambda_v
+    	  sigma = Math.atan2(sin_sigma, cos_sigma)
+    	  sin_alpha= cos_u1  * cos_u2 * sin_lambda_v / sin_sigma 
+    	  cos_2_alpha = 1 - sin_alpha * sin_alpha #trig identity 	 
+    	  cos_2_sigma_m = cos_sigma - 2 * sin_u1 * sin_u2/cos_2_alpha
+    	  c = f / 16 * cos_2_alpha * (4 + f*(4-3*cos_2_alpha))
+    	  lambda_dash = lambda_v
+    	  lambda_v = l + (1-c) * f * sin_alpha * (sigma + c * sin_sigma * (cos_2_sigma_m + c * cos_sigma * (-1 + 2 * cos_2_sigma_m * cos_2_sigma_m) ) )  # use cos_2_sigma_m=0 when over equatorial lines
+    	  if lambda_v > Math::PI
+    	    lambda_v = Math::PI
+    	    break
+        end
+      end
+
+      u_2 = cos_2_alpha * (a * a - b * b) / (b * b)
+      a1 = 1 + u_2 / 16384 * (4096 + u_2 * (-768 + u_2 * (320 - 175 * u_2)))
+      b1 = u_2 / 1024 * (256 + u_2 * (-128 + u_2 * (74 - 47 * u_2)))
+      delta_sigma = b1 * sin_sigma * (cos_2_sigma_m + b1 / 4 * (cos_sigma * (-1 + 2 * cos_2_sigma_m * cos_2_sigma_m) - b1 / 6 * cos_2_sigma_m * (-3 + 4 * sin_sigma * sin_sigma) * (-3 + 4 * cos_2_sigma_m * cos_2_sigma_m)))
+      s = b * a1 * (sigma - delta_sigma)
+      sin_lambda_v = Math.sin(lambda_v)
+      cos_lambda_v = Math.cos(lambda_v)
+      
+      #This test isn't in original formulae, and fixes the problem of all angles returned being between 0 - PI (0-180)
+      #Also converts the result to compass bearing, rather than the mathmatical anticlockwise angles.
+      if(Math.sin(p2.longitude.to_r - @longitude.to_r) < 0)
+        alpha_1 = Math::PI*2-Math.atan2( cos_u2 * sin_lambda_v, cos_u1 * sin_u2 - sin_u1 * cos_u2 * cos_lambda_v)
+        #alpha_2 = Math::PI*2-Math.atan2(cos_u1 * sin_lambda_v, -sin_u1 * cos_u2 + cos_u1 * sin_u2 * cos_lambda_v)
+      else
+        alpha_1 = Math.atan2( cos_u2 * sin_lambda_v, cos_u1 * sin_u2 - sin_u1 * cos_u2 * cos_lambda_v)
+        #alpha_2 = Math.atan2(cos_u1 * sin_lambda_v, -sin_u1 * cos_u2 + cos_u1 * sin_u2 * cos_lambda_v)
+      end
+  
+    #Note that the bearing is a compass (i.e. clockwise) angle.
+    return TrackAndDistance.new(alpha_1, s, true) #What to do with alpha_2?
+  end
+
+  #spherical earth estimate of calculation for finding target coordinate from start coordinate, bearing and distance
+  #Used to run checks on the Vincenty algorithm
+  #Takes: TrackAndDistance object with bearing and distance.
+  #Returns new Vincenty object with the destination coordinates.
+  def sphereDestination( track_and_distance )
+    a = 6378137 #equatorial radius in meters     (±2 m) 
+    b = 6356752.31424518 #polar radius in meters
+    r = (a+b)/2 #average diametre as a rough estimate for our tests.
+    
+    d = track_and_distance.distance.abs
+    sin_dor = Math.sin(d/r)
+    cos_dor = Math.cos(d/r)
+    sin_lat1 = Math.sin(@latitude.to_r)
+    cos_lat1 = Math.cos(@latitude.to_r)
+    lat2 = Math.asin( sin_lat1 * cos_dor + cos_lat1 * sin_dor * Math.cos(track_and_distance.bearing.to_r) )
+    lon2 = @longitude.to_r + Math.atan2(Math.sin(track_and_distance.bearing.to_r) * sin_dor * cos_lat1, cos_dor-sin_lat1 * Math.sin(lat2))
+    
+    Vincenty.new(lat2, lon2, 0, true);
+  end
+
+  #
+  # Calculate destination point given start point lat/long, bearing and distance.
+  #Assumes earth is a WGS-84 Ellipsod.
+  #Takes: TrackAndDistance object with bearing and distance.
+  #Returns: new Vincenty object with the destination coordinates.
+
+  def destination( track_and_distance ) 
+    # a, b = major & minor semiaxes of the ellipsoid
+    a = 6378137 #equatorial radius in meters     (±2 m) 
+    b = 6356752.31424518 #polar radius in meters
+    f = (a-b)/a #  flattening 
+    
+    s = track_and_distance.distance.abs;
+    alpha1 = track_and_distance.bearing.to_r
+    sin_alpha1 = Math.sin(alpha1)
+    cos_alpha1 = Math.cos(alpha1)
+  
+    tanU1 = (1-f)  *  Math.tan(@latitude.to_r);
+    cosU1 = 1 / Math.sqrt((1  +  tanU1 * tanU1))
+    sinU1 = tanU1 * cosU1
+    sigma1 = Math.atan2(tanU1, cos_alpha1)
+    sin_alpha = cosU1  *  sin_alpha1
+    cos_2_alpha = 1 - sin_alpha * sin_alpha #Trig identity
+    u_2 = cos_2_alpha  *  (a * a - b * b) / (b * b)
+    a1 = 1  +  u_2/16384 * (4096 + u_2 * (-768 + u_2 * (320-175 * u_2)))
+    b1 = u_2/1024  *  (256 + u_2 * (-128 + u_2 * (74-47 * u_2)))
+  
+    sigma = s / (b * a1)
+    sigma_dash = 2 * Math::PI
+    while ((sigma-sigma_dash).abs > 1.0e-12) #i.e 0.06mm
+      cos_2_sigma_m = Math.cos(2 * sigma1  +  sigma)
+      sin_sigma = Math.sin(sigma)
+      cos_sigma = Math.cos(sigma)
+      delta_sigma = b1 * sin_sigma * (cos_2_sigma_m + b1/4 * (cos_sigma * (-1 + 2 * cos_2_sigma_m * cos_2_sigma_m) - b1/6 * cos_2_sigma_m * (-3 + 4 * sin_sigma * sin_sigma) * (-3 + 4 * cos_2_sigma_m * cos_2_sigma_m)))
+      sigma_dash = sigma
+      sigma = s / (b * a1)  +  delta_sigma
+    end
+
+    tmp = sinU1 * sin_sigma - cosU1 * cos_sigma * cos_alpha1
+    lat2 = Math.atan2(sinU1 * cos_sigma  +  cosU1 * sin_sigma * cos_alpha1,  (1-f) * Math.sqrt(sin_alpha * sin_alpha  +  tmp * tmp))
+    lambda_v = Math.atan2(sin_sigma * sin_alpha1, cosU1 * cos_sigma - sinU1 * sin_sigma * cos_alpha1)
+    c = f/16 * cos_2_alpha * (4 + f * (4-3 * cos_2_alpha))
+    l = lambda_v - (1-c)  *  f  *  sin_alpha  *  (sigma  +  c * sin_sigma * (cos_2_sigma_m + c * cos_sigma * (-1 + 2 * cos_2_sigma_m * cos_2_sigma_m))) #difference in longitude
+
+    #sigma2 = Math.atan2(sin_alpha, -tmp)  # reverse azimuth
+  
+    return Vincenty.new(lat2, @longitude + l, 0, true);
+  end
+
+
+end
+
+
+

data/test/ts_all.rb

@@ -0,0 +1,4 @@
+require 'ts_angle.rb'
+require 'ts_vincenty.rb'
+require 'latitude.rb'
+require 'longitude.rb'

data/test/ts_angle.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'vincenty.rb'
+
+class TestAngle< Test::Unit::TestCase
+  #test Angle creation
+  def test_angle
+    assert_equal(Angle.new(), 0)
+    assert_equal(Angle.new("S37°01′7.5″").to_d,  -37.01875) #Leading NSEW
+    assert_equal(Angle.new("37°01′7.5″S").to_d ,  -37.01875) #Trailing NSEW
+    assert_equal(Angle.new("-37°01′7.5″").to_d,  -37.01875) #Use of - rather than S or W
+    assert_equal(Angle.new("-37° 1.125′").to_d, -37.01875) #Decimal minutes, rather than minutes and seconds.
+    assert_equal(Angle.new("-37°01′.125").to_d, -37.01875) #Nb. the minute marker ' between the minutes and fraction
+    assert_equal(Angle.new("S37°01′.125").to_d, -37.01875) #Nb. the minute marker ' between the minutes and fraction
+    assert_equal(Angle.new("37°01′.125S").to_d, -37.01875) #Nb. the minute marker ' between the minutes and fraction
+    assert_equal(Angle.new("-37.01875°").to_d, -37.01875) #decimal degrees, rather than deg, min, sec.
+    assert_equal(Angle.new([-37, 1, 7.5]).to_d,  -37.01875) #an array of deg,min,sec
+    assert_equal(Angle.new(-37.01875).to_d, -37.01875)
+    assert_equal(Angle.degrees(-37.01875).to_d, -37.01875)
+    assert_equal(Angle.degrees(-37.01875).to_r.round(15), -0.646099072472651)
+    assert_equal(Angle.new(-0.646099072472651, true).to_d.round(5), -37.01875)
+    assert_equal(Angle.new(-0.646099072472651, true).to_r, -0.646099072472651)
+    assert_equal(Angle.radians(-0.646099072472651).to_d.round(5), -37.01875)
+  end
+  
+  def test_strf
+    a = Angle.new("S37°01′7.5″")
+    assert_equal("37°01′07.50000″S", a.strf( "%d°%2m′%2.5s″%N" ))
+    assert_equal("37°01′07.50000″W", a.strf("%d°%2m′%2.5s″%E" ))
+    assert_equal("-37°01′07.5000″", a.strf("%d°%2m′%2.4s″" ))
+    assert_equal("-37°01.1250′\n", a.strf("%d°%2.4M′\n" ))
+    assert_equal("*** -37°01′.1250", a.strf( "*** %d°%2m′%4W" )) #puting the minute ' before decimal point.
+    assert_equal("-37.01875°", a.strf("%0.5D°" ))
+    assert_equal("-0.64610 radians\n", a.strf("%0.5r radians\n" ))
+
+    assert_equal("-037°01′7.5000″", Angle.new("-37°01′7.5″").to_s('%3d°%2m′%1.4s″')) #testing leading 0 with -deg, no leading 0 %s
+    assert_equal("00°01′07.5000″S", Angle.new("0°01′7.5″S").to_s('%2d°%2m′%2.4s″%N')) #testing 0 degrees and leading 0 %s
+    assert_equal("00°-01′07.5000″", Angle.new("0°01′7.5″S").to_s('%2d°%2m′%2.4s″')) #testing 0 degrees and -min
+    assert_equal("00°-01′07.5000″", Angle.new("0°01′7.5″S").to_s('%2d°%2m′%2.4s″') ) #test of 0 degrees, -min, no NSEW
+    assert_equal("000°00′07.5000″W", Angle.new("0°0′7.5″W").to_s('%3d°%2m′%2.4s″%E') ) #testing E W 0 deg and 0 min and -sec
+    assert_equal("00°00′-07.5000″", Angle.new("0°0′7.5″S").to_s('%2d°%2m′%2.4s″') ) #testing 0 deg and 0 min and -sec no NSEW
+  end
+
+  def test_operators
+    #Comparable.
+    assert_equal(Angle.radians(-0.646099072472651), Angle.radians(-0.646099072472651)) #<=>   
+    #unary-op Angle
+    assert_equal(+Angle.radians(-0.646099072472651), Angle.radians(-0.646099072472651)) #unary +
+    assert_equal(-Angle.radians(-0.646099072472651), Angle.radians(0.646099072472651)) #unary -
+    #Angle op Numeric
+    assert_equal(5, Angle.radians(2) +  3) # +
+    assert_equal(-1, Angle.radians(2) -  3) # -
+    assert_equal(6, Angle.radians(2) *  3) # *
+    assert_equal(2, Angle.radians(4) /2) # /
+    assert_equal(1, Angle.radians(4) % 3) # %
+    assert_equal(64, Angle.radians(4) ** 3) # **
+    #Numeric op Angle
+    assert_equal(5.1, 3.1 + Angle.radians(2) ) # +
+    assert_equal(2.646099072472651, 2 - Angle.radians(-0.646099072472651) ) # -
+    assert_equal(6, 3 * Angle.radians(2) ) # *
+    assert_equal(2, 4 / Angle.radians(2) ) # /
+    #Angle op Angle
+    assert_equal(Angle.radians(3.2+2.1), Angle.radians(3.2) + Angle.radians(2.1) ) # +   
+    #Sign method.
+    assert_equal(1, Angle.radians(3).sign)
+    assert_equal(-1, Angle.radians(-3).sign)
+    #abs
+    assert_equal(3, Angle.radians(-3).abs)
+    #reverse
+    assert_equal(Angle.degrees(90), Angle.degrees(270).reverse)
+    #bearing
+    assert_equal(Angle.degrees(340), Angle.degrees(20).to_bearing)
+  end
+end

data/test/ts_latitude.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'vincenty.rb'
+
+class TestAngle< Test::Unit::TestCase
+  def test_strf
+    assert_equal("37°01′07.5000″S", Latitude.new("S37°01′7.5″").to_s)
+    assert_equal("37°01′07.5000″S", Latitude.new("-37°01′7.5″").to_s)
+    assert_equal("37°01′07.5000″S", Latitude.new("37°01′7.5″S").to_s)
+    assert_equal("37°01′07.5000″N", Latitude.new("N37°01′7.5″").to_s)
+    assert_equal("37°01′07.5000″N", Latitude.new("37°01′7.5″").to_s)
+    assert_equal("37°01′07.5000″N", Latitude.new("37°01′7.5″N").to_s)
+  end
+  def test_to_radians
+    assert_equal(Math::PI/4, Latitude.degrees(45).to_r)
+    assert_equal(Math::PI/4, Latitude.degrees(135).to_r)
+    assert_equal(-Math::PI/4, Latitude.degrees(225).to_r)
+    assert_equal(-Math::PI/4, Latitude.degrees(315).to_r)
+  end
+  def test_to_degrees
+    assert_equal(45, Latitude.degrees(45).to_d)
+    assert_equal(45, Latitude.degrees(135).to_d)
+    assert_equal(-45, Latitude.degrees(225).to_d)
+    assert_equal(-45, Latitude.degrees(315).to_d)
+    assert_equal(1, Latitude.degrees(179).to_d)
+    assert_equal(-1, Latitude.degrees(181).to_d)
+    assert_equal(-89, Latitude.degrees(269).to_d)
+    assert_equal(-89, Latitude.degrees(271).to_d)
+    assert_equal(89, Latitude.degrees(89).to_d)
+    assert_equal(89, Latitude.degrees(91).to_d)
+  end
+end

data/test/ts_longitude.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'vincenty.rb'
+
+class TestAngle< Test::Unit::TestCase
+  def test_strf
+    assert_equal("037°01′07.5000″W", Longitude.new("W37°01′7.5″").to_s)
+    assert_equal("037°01′07.5000″W", Longitude.new("-37°01′7.5″").to_s)
+    assert_equal("037°01′07.5000″W", Longitude.new("37°01′7.5″W").to_s)
+    assert_equal("037°01′07.5000″E", Longitude.new("E37°01′7.5″").to_s)
+    assert_equal("037°01′07.5000″E", Longitude.new("37°01′7.5″").to_s)
+    assert_equal("037°01′07.5000″E", Longitude.new("37°01′7.5″E").to_s)
+  end
+  def test_to_radians
+    assert_equal(Math::PI/4, Longitude.degrees(45).to_r)
+    assert_equal(3*Math::PI/4, Longitude.degrees(135).to_r)
+    assert_equal(-3*Math::PI/4, Longitude.degrees(225).to_r)
+    assert_equal(-Math::PI/4, Longitude.degrees(315).to_r)
+  end
+  def test_to_degrees
+    assert_equal(45, Longitude.degrees(45).to_d)
+    assert_equal(135, Longitude.degrees(135).to_d)
+    assert_equal(-135, Longitude.degrees(225).to_d)
+    assert_equal(-45, Longitude.degrees(315).to_d)
+  end
+end

data/test/ts_vincenty.rb

@@ -0,0 +1,96 @@
+require 'test/unit'
+require 'vincenty'
+
+class TestVincenty< Test::Unit::TestCase
+
+  def initialize(x)
+    super(x)
+    
+    @path = [ #Path starting at peg by kanaka at end of drive 
+       TrackAndDistance.new("215,3,0", 19.73 ) ,
+       TrackAndDistance.new(Angle.new("320,14,10").reverse, 12.0), #Note don't need to add the radians=true argument as Angle has to_radians function
+       TrackAndDistance.new(Angle.new("281,44,40").reverse, 35.23 ),
+       TrackAndDistance.new(Angle.new("247,24,0").reverse, 40.23 ),
+       TrackAndDistance.new(Angle.new("218,19,0").reverse, 378.98 ),
+       TrackAndDistance.new(Angle.new("158,25,0").reverse, 128.39 ),
+       TrackAndDistance.new(Angle.new("17,7,40").reverse, 122.41 ),
+       TrackAndDistance.new(Angle.new("51,1,0").reverse, 288.89 ),
+       TrackAndDistance.new("158,47,30", 61.78 ),
+       TrackAndDistance.new("189,16,10", 26.26 ),
+       TrackAndDistance.new("217,14,0", 21.87 ),
+    ]
+
+    @waypoints = [
+        Vincenty.new(-36.9923293459124, 174.485341187381),
+        Vincenty.new(-36.992412464006, 174.485427409127),
+        Vincenty.new(-36.9924770796644, 174.485814875954),
+        Vincenty.new(-36.9923377696042, 174.486232091137),
+        Vincenty.new(-36.9896584018239, 174.488871503953),
+        Vincenty.new(-36.988582616694, 174.488340992344),
+        Vincenty.new(-36.9896367145752, 174.487936042043),
+        Vincenty.new(-36.9912743090293, 174.48541348615),
+        Vincenty.new(-36.9917932943506, 174.485664544705),
+        Vincenty.new(-36.9920268289562, 174.485617028991),
+        Vincenty.new(-36.9921837292671, 174.485468381511),
+    ]  
+  end
+
+  #The path in @path was entered from the property survey map, with distance and bearings which should form a closed loop
+  #verified on google map of my property by creating a KML file and loading the map over the satellite image and checking the
+  #coordinates in google earth, and visually checking the route created was a closed loop (it was with a tiny error). 
+  def test_vincenty_destination
+    start = Vincenty.new(-36.9921838030711, 174.485468469841) 
+
+    next_p = start
+#    print "Start at coordinate #{next_p.longitude.to_d}, #{next_p.latitude.to_d}\n"
+    @path.each_with_index do |leg,i|
+      next_p, spherical_ans = next_p.destination( leg ) , next_p.sphereDestination(leg)
+ 
+      assert_equal(@waypoints[i].longitude.to_d.round(12), next_p.longitude.to_d.round(12))
+      assert_equal(@waypoints[i].latitude.to_d.round(12), next_p.latitude.to_d.round(12))
+  #    print "Expect  #{waypoints[i].longitude.to_d.round(4)}, #{waypoints[i].latitude.to_d.round(4)}\n"
+  #    print "Moved #{leg.bearing.to_d.round(4)} #{leg.distance.round(4)}m to #{next_p.longitude.to_d.round(4)}, #{next_p.latitude.to_d.round(4)}\n"
+  #    print "Spherical #{leg.bearing.to_d.round(4)} #{leg.distance.round(4)}m to #{spherical_ans.longitude.to_d.round(4)}, #{spherical_ans.latitude.to_d.round(4)}\n"
+  #    puts
+    end
+  #  assert_equal(0, next_p.distanceAndAngle(start).distance)
+  #  puts "distance from end to start should be 0. Actual #{next_p.distanceAndAngle(start)}"
+  end
+  
+  #The waypoints are the latitudes and longitudes of the corners of my property.
+  #The resulting bearing and distances between them should match those in @path.
+  def test_vincenty_distance_and_angle
+    start = Vincenty.new(-36.9921838030711, 174.485468469841) 
+    next_p = start
+#   print "\nReverse test, c\n"
+#    print "Start at coordinate #{next_p.longitude.to_d}, #{next_p.latitude.to_d}\n"
+    @waypoints.each_with_index do |point,i|
+      vtrack_and_bearing = next_p.distanceAndAngle( point ) 
+  #    strack_and_bearing = next_p.sphericalDistanceAndAngle( point )
+      
+      assert_equal(@path[i].bearing.to_d.round(4), vtrack_and_bearing.bearing.to_d.round(4))
+      assert_equal(@path[i].distance.round(4), vtrack_and_bearing.distance.round(4))
+  #    print "Expected #{path[i].bearing.to_d.round(4)}(#{((path[i].bearing.to_d+180)%360).round(4)}), #{path[i].distance.round(4)}m\n"
+  #    print "WGS-84 track #{vtrack_and_bearing.bearing.to_d.round(4)} #{vtrack_and_bearing.distance.round(4)}m from #{next_p.longitude.to_d.round(4)}, #{next_p.latitude.to_d.round(4)} to #{point.longitude.to_d.round(4)},  #{point.latitude.to_d.round(4)}\n"
+  #    print "Spherical track #{strack_and_bearing.bearing.to_d.round(4)} #{strack_and_bearing.distance.round(4)}m from #{next_p.longitude.to_d.round(4)}, #{next_p.latitude.to_d.round(4)} to #{point.longitude.to_d.round(4)},  #{point.latitude.to_d.round(4)}\n"
+  #    puts
+      next_p = point
+    end
+  # assert_equal(0, next_p.distanceAndAngle(start).distance)
+  #  puts "distance from end to start should be 0. Actual #{next_p.distanceAndAngle(start)}\n"
+  end
+  
+  #Run the Australian Geoscience site example.
+  def test_geoscience_au
+    flindersPeak = Vincenty.new("-37°57'3.72030″", "144°25'29.52440″" )
+    buninyong = Vincenty.new("-37 ° 39 ' 10.15610 ''", "143 ° 55 ' 35.38390 ''") #Buninyong
+    track_and_bearing = flindersPeak.distanceAndAngle( buninyong ) 
+    assert_equal(Angle.new("306 ° 52 ' 5.37 ''").to_d.round(4), track_and_bearing.bearing.to_d.round(4))
+    assert_equal(54972.271, track_and_bearing.distance.round(3))
+    
+    destination = flindersPeak.destination(TrackAndDistance.new("306 ° 52 ' 5.37 ''", 54972.271))
+    assert_equal(buninyong.latitude.to_d.round(4), destination.latitude.to_d.round(4))
+    assert_equal(buninyong.longitude.to_d.round(4), destination.longitude.to_d.round(4))
+  end
+    
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: vincenty
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- Rob Burrowes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-03 00:00:00 +13:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.9.0
+    version: 
+description: "* Vincenty wrote an algorithm for calculating the bearing and distance between two coordinates on the earth and an algorithm for finding a second coordinate, given a starting coordinate, bearing and destination. The algorithms model the earth as an ellipsoid, using the WGS-84 model. This is the common GPS model for mapping to latitudes and longitudes.  This is a Ruby implementation of Vincenty's algorithms, and the Vincenty class includes two methods for  modeling the earth as a sphere. These were added as a reference for testing the Vincenty algorithm, but could be used on their own.   The package also makes use of several other classes that may be useful in their own Right. These include class Angle, class Latitude (subclass of Angle), class Longitude (subclass of Angle),  class TrackAndBearing and class coordinate (which class Vincenty is a subclass)  Angle requires extensions to Numeric and String to provide to_radians (to_r) and to_degrees (to_d). String also includes a to_decimal_degrees(), which converts most string forms of Latitude and Longitude to decimal form. These extensions are included in the package in core_extensions.rb. Float has also been extended to change round to have an optional argument specifying the number of decimal places to round to. This is fully compatible with the Float.round, as the default is to round to 0 decimal places.  *  The Vincenty code is based on the wikipedia presentation of the Vincenty algorithm http://en.wikipedia.org/wiki/Vincenty%27s_formulae . *  The algorithm was modified to include changes I found at http://www.movable-type.co.uk/scripts/latlong-vincenty-direct.html. *  I also altered the formulae to correctly return the bearing for angles greater than 180.   * Vincenty's original publication  ** T Vincenty, \"Direct and Inverse Solutions of Geodesics on the Ellipsoid with application of nested equations\", Survey Review, vol XXII no 176, 1975 http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf"
+email: 
+- rob@burrowes.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/angle.rb
+- lib/coordinate.rb
+- lib/core_extensions.rb
+- lib/latitude.rb
+- lib/longitude.rb
+- lib/track_and_distance.rb
+- lib/vincenty.rb
+- test/ts_all.rb
+- test/ts_angle.rb
+- test/ts_latitude.rb
+- test/ts_longitude.rb
+- test/ts_vincenty.rb
+has_rdoc: true
+homepage: "\"http://rubyforge.org/projects/vincenty/\""
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: vincenty
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: "* Vincenty wrote an algorithm for calculating the bearing and distance between two coordinates on the earth and an algorithm for finding a second coordinate, given a starting coordinate, bearing and destination"
+test_files: []
+