vincenty 1.0.3 → 1.0.4

data/History.txt

@@ -1,3 +1,25 @@
+=== 1.0.1 / 2009-03-03
+
+* 1 major enhancement
+
+  * Birthday!
+
+commit 1af085d57d8f5486b31fef3e018fa75a1e634028
+Author: rbur004 <rob@burrowes.org>
+Date:   Fri Jan 1 11:10:33 2010 +1300
+
+    Found the error generating gems with gem 1.3.5 and Hoe. The url in README.txt should not have quotes around it.
+    
+    Also the new way to specify the URL in the Rakefile is to use self.url. Kind of ugly really.
+    
+    Also noted that Hoe is adding itself as a dependency in the gemspec, which it is not.
+
+commit acc43b4a37c6cf878b9415524b8b720d46fec48b
+Author: rbur004 <rob@burrowes.org>
+Date:   Thu Dec 31 23:39:08 2009 +1300
+
+    Commented out the require 'lib/vincenty.rb' as it is no longer required
+
 commit e8d8d9bce43f58b0bd487e48308f170ca48c380d
 Author: rbur004 <rob@burrowes.org>
 Date:   Thu Dec 31 22:50:16 2009 +1300

data/Manifest.txt

@@ -1,6 +1,6 @@
 History.txt
 Manifest.txt
-README.txt
+README.md
 Rakefile
 lib/angle.rb
 lib/coordinate.rb

data/{README.txt → README.md}

@@ -1,8 +1,10 @@
-= Vincenty
+# Vincenty
 
-* "http://rubyforge.org/projects/vincenty/"
+* http://rbur004.github.com/vincenty/
+* Source https://github.com/rbur004/vincenty
+* Gem https://rubygems.org/gems/vincenty
 
-== DESCRIPTION:
+## 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.
@@ -27,13 +29,13 @@
 
 ** 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:
+## FEATURES/PROBLEMS:
 
 * None that I yet know of :)
 
-== SYNOPSIS:
+## SYNOPSIS:
 
-  flindersPeak = Vincenty.new("-37°57′3.72030″", "144°25′29.52440″" )
+  flindersPeak = Vincenty.new("-37°57′3.72030''", "144°25′29.52440''" )
   buninyong = Vincenty.new("-37° 39' 10.15610''", "143° 55' 35.38390''")
   track_and_bearing = flindersPeak.distanceAndAngle( buninyong )
   puts track_and_bearing
@@ -45,15 +47,15 @@
   #Angles is the parent class of Latitude and Longitude
   Angle.new("-37°01′.125").strf( "The angle is %d°%2m′%2.5s″%N" ) -> "The angle is 37°01′07.50000″S"
   
-== REQUIREMENTS:
+## REQUIREMENTS:
 
 * require 'rubygems'
 
-== INSTALL:
+## INSTALL:
 
 * sudo gem install vincenty
 
-== LICENSE:
+## LICENSE:
 
 Code unique to this implementation of Vincentys algrithm is distributed under the Ruby License.
 
@@ -65,42 +67,25 @@ Copyright (c) 2009
 
 2. You may modify your copy of the software in any way, provided that
    you do at least ONE of the following:
+    *  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.
+    *  use the modified software only within your corporation or organization.
+    *  rename any non-standard executables so the names do not conflict with standard executables, which must also be provided.
+    *  make other distribution arrangements with the author.
 
-     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,
+3. You may distribute the software in object code or executable form, provided that you do at least ONE of the following:
+    * 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
+    * accompany the distribution with the machine-readable source of
   the software.
-
-     c) give non-standard executables non-standard names, with
+    * 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.
+    * 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.
+   software (possibly commercial).  But some files or libraries used by
+   code in this distribution  may not written by the author, so that they 
+   are not under these terms.
 
 5. The scripts and library files supplied as input to or produced as 
    output from the software do not automatically fall under the

data/Rakefile

@@ -1,17 +1,20 @@
 #!/usr/bin/ruby
 # -*- ruby -*-
 
-#require 'rubygems'
+require 'rubygems'
 require 'hoe'
 #require 'lib/vincenty.rb'
-
+Hoe.plugin :yard
 
 Hoe.spec 'vincenty' do 
   self.rubyforge_name = "vincenty" 
-  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")
-  remote_rdoc_dir = '' # Release to root
+  self.developer( "Rob Burrowes","r.burrowes@auckland.ac.nz")
+  
+  self.yard_title = 'Vincenty'
+  self.yard_options = ['--markup', 'markdown', '--protected']
+  #self.url = "http://www.wikarekare.org"
+  #self.summary = "Vincenty Algorithm for Distance, Bearing between Map Coordinates." 
+  #self.description = s.paragraphs_of('README.txt', 1..4).join("\n\n")
+  #self.remote_rdoc_dir = '' # Release to root
 end
 

data/lib/angle.rb

@@ -1,140 +1,171 @@
+require 'core_extensions.rb'
+
 #Class Angle is a utility class that allows 
-# * Angle arithmetic
-# * Angle comparison
+# * Angle arithmetic ( +,-,*,/,**,% and unary +,-)
+# * Angle comparison ( <=>, hence, <, >, >=, <=, == )
 # * 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
+  attr_accessor :angle #stored in radians
+  alias :value :angle    #Older version of angle used volue rather than angle
+  alias :value= :angle=  #Older version of angle used volue rather than angle
   
-  #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.
+  #angle may be anything that has a to_f and to_radians. 
+  #The Default for angle is degrees, but internally @angle is stored in radians.
+  #if radians is passed true or :radians, then angle is in radians, not degrees.
+  def initialize(angle=0, radians=false)
+    #assumes that we are getting an angle in degrees.
+    if radians == true || radians == :radians
+      @angle = angle.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.
+      if angle.class == Array
+        @angle = self.class.decimal_deg(*angle).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.
+        @angle = angle.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]]
+  
+  #Class level function that converts 4 arguments into decimal degrees.
+  #Dircection is one of 'N', 'S', 'E', 'W'.
+  # direction is optional, as you might want to specify a negative value for degrees
+  # @return [Float] signed decimal degrees.
+  def self.decimal_deg(degrees=0, minutes=0, seconds=0, direction='N')
+    s = { 'N'=>1, 'S'=>-1, 'E'=>1, 'W'=>-1, 'n'=>1, 's'=>-1, 'e'=>1, 'w'=>-1 }
+    sign = s[direction]
+    sign = sign == nil ? 1 : sign #Assume 'N' or 'E' if the direction is not set.
+    #Shouldn't have a negative value for degrees if the direction is specified.
+    #I am defaulting to the degrees sign if it is set, otherwise the direction given
+    sign = degrees.sign == -1 || (degrees == 0 && (minutes < 0 || (minutes == 0 && seconds < 0))) ? -1 : sign
+    sign * (degrees.abs + minutes/60.0 + seconds/3600.0) 
+  end
+  
+  #Class level function that takes an array of [degress,minutes, seconds, direction]
+  # and returns decimal degrees
+  # @return [Float] signed decimal degrees.
+  def self.decimal_deg_from_ary(a)
+    self.decimal_deg(*a)
   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
+  #Class level utility function to return the angle as deg,min,sec
+  #Assumes decimal degress unless radians == true .
+  # @return [Array] of signed 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 self.dms(angle, radians = false)
+    angle = angle.to_d if radians == true || radians == :radians
+    v = angle.abs
     deg = v.floor
-    min = ((v-@deg)*60).floor
-    sec = ((v-@deg-min/60.0)*3600.0) 
+    min = ((v-deg)*60.0).floor
+    sec = ((v-deg-min/60.0)*3600.0) 
     
-    if v < 0 &&  deg == 0
-      if min == 0
-        sec = -sec
+    if angle < 0
+      if deg == 0
+        if min == 0
+          sec = -sec
+        else
+          min = -min 
+        end
       else
-        min = -min 
+        deg = -deg
       end
     end
+
     return deg,min,sec
   end
      
   #Class level function equivalent to Angle.new(r, true)
-  #Returns: new Angle
+  # @return [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
+  # @return [Angle]
   def self.degrees(d=0) #passed in degrees.
     self.new(d.to_radians, true)
   end
     
+  #Provides test for Module Comparable, giving us <,>,<=,>=,== between angles
+  # @return [true,false]
+  def <=>(angle)
+    if angle.class == Angle
+      @angle <=> angle.angle
+    else 
+      @angle <=> angle
+    end
+  end
+
   #unary +
-  #Returns: new Angle
+  # @return [Angle] equivalent to @angle
   def +@
-    self.class.radians(@value) #Nb. Not Angle.new, as we want subclasses to return their class, not Angle.
+    self.class.radians(@angle) #Nb. Not Angle.new, as we want subclasses to return their class, not Angle.
   end
   
   #Unary -
-  #Returns: new Angle
+  # @return [Angle] -@angle
   def -@
-    self.class.radians(-@value)
+    self.class.radians(-@angle)
   end
   
-  #Returns :new Angle
-  def +(v)
-    self.class.radians(@value + v)
+  # Binary addition operator. Can add angles and numbers, or two angles.
+  # @return [Angle]
+  def +(angle)
+    self.class.radians(@angle + angle)
   end
   
-  #Returns: new Angle
-  def -(v)
-    self.class.radians(@value - v)
+  # Binary subtraction operator. Can add angles and numbers, or two angles.
+  # @return [Angle]
+  def -(angle)
+    self.class.radians(@angle - angle)
   end
     
-  #Returns :new Angle
-  def *(v)
-    self.class.radians(@value * v)
+  # Binary multiply operator. Can add angles and numbers, or two angles.
+  # @return [Angle]
+  def *(angle)
+    self.class.radians(@angle * angle)
   end
   
-  #Returns: new Angle
-  def **(v)
-    self.class.radians(@value ** v)
+  # Binary power of operator. Can add angles and numbers, or two angles.
+  # @return [Angle]
+  def **(angle)
+    self.class.radians(@angle ** angle)
   end
   
-  #Returns: new Angle
-  def /(v)
-    self.class.radians(@value / v)
+  # Binary division operator. Can add angles and numbers, or two angles.
+  # @return [Angle]
+  def /(angle)
+    self.class.radians(@angle / angle)
   end
   
-  #Returns: new Angle
-  def %(v)
-    self.class.radians(@value % v)
+  # Binary mod operator. Can add angles and numbers, or two angles.
+  # @return [Angle]
+  def %(angle)
+    self.class.radians(@angle % angle)
   end
     
-  #Returns: angle in degrees
+  # @return [Float] angle in degrees
   def to_degrees
-    @value.to_degrees
+    @angle.to_degrees
   end
  
+  # @return [Float] angle in degrees
   alias to_d to_degrees
   
   #Returns: angle in radians
   def to_radians
-    @value
+    @angle
   end
 
   alias to_r to_radians
   
-  #Returns: [deg,min,sec]
+  # Returns @angle as decimal_degrees
+  # @return [Array]  of signed Floats: degrees,minutes,seconds
   #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 
@@ -143,7 +174,7 @@ class Angle
     min = ((d-deg)*60).floor
     sec = ((d-deg-min/60.0)*3600.0) 
     
-    if @value < 0
+    if @angle < 0
       if deg == 0
         if min == 0
           sec = -sec
@@ -158,76 +189,78 @@ class Angle
     return deg, min, sec
   end
   
-  #Returns: the angle in radians as a float (equivalent to to_radians)
+  # @return [Float] 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.
+  # @return [Fixnum] the angle truncated to an integer, in radians.
   def to_i
     to_radians.to_i
   end
   
+  # @return [Fixnum] the angle truncated to an integer, in radians.
   alias to_int to_i
   
-  def coerce(v)
-    [Float(v), @value]
+  # @return [Array] the angle parameter as a Float and the @angle parameter from this class.
+  def coerce(angle)
+    [Float(angle), @angle]
   end
   
-  #Returns: the sign of the angle. 1 for positive, -1 for negative.
+  # @return [Fixnum] the sign of the angle. 1 for positive, -1 for negative.
   def sign
-    @value.sign
+    @angle.sign
   end
   
-  #Returns: the absolute value of the angle in radians
+  # @return [Float] the absolute angle of the angle in radians
   def abs
-    @value.abs
+    @angle.abs
   end
   
-  #Returns: angle as compass bearing in radians.
+  # @return [Float] 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)
+    self.class.new(Math::PI * 2 - @angle,true)
   end
   
-  #Returns: the reverse angle in radians. i.e. angle + PI (or angle + 180 degrees)
+  # @return [Float] 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
+    if (angle = @angle + Math::PI) > Math::PI * 2
+      angle -= Math::PI * 2
     end
-    return self.class.new(v,true)
+    return self.class.new(angle,true)
   end
   
   
-  #Returns: angle in radians as a string.
+  # @return [String] 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.
+  #The default format is a signed deg 0minutes'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°
+  # *** 2 indicates that at least 2 digits are displayed. 1 to 9 will be displayed as 01 0 to 09 0
+  # *** 3 indicates that at least 4 digits are displayed. 10 to 99 will be displayed as 010 0 to 099 0
   #
   # * %w.pD outputs degrees as a float.
-  # ** p is the number of decimal places.
+  #     * 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.
+  #     * 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.
+  # * %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.
+  #       Used with %m like this %2m'%4W , to get minute marker before the decimal places. 
+  #       e.g. -37 001'.1167 rather than -37 001.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.
+  #     * 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.
   #
@@ -238,7 +271,8 @@ class Angle
   # * %% outputs %
   #
   # Other strings in the format are printed as is.
-  def strf(fmt="%d°%2m′%2.4s″")
+  # @return [String]
+  def strf(fmt="%d %2m'%2.4s\"")
     tokens = fmt.scan(/%[0-9\.]*[%dmsDMNErW]|[^%]*/)
     have_dir = have_dms = false
     tokens.collect! do |t|
@@ -288,7 +322,7 @@ class Angle
         when 'd'
           s += s_int(deg, t[1], have_dir)
         when 'D'
-          s += s_float(@value.to_d, t[1], t[2], have_dir)
+          s += s_float(@angle.to_d, t[1], t[2], have_dir)
         when 'm'
           s += s_int(min, t[1], have_dir)
         when 'M'
@@ -298,11 +332,11 @@ class Angle
         when 's'
           s += s_float(sec, t[1], t[2], have_dir)
         when 'r'
-          s += s_float(@value, t[1], t[2], have_dir)
+          s += s_float(@angle, t[1], t[2], have_dir)
         when 'N'
-          s +=  (@value < 0 ? 'S' : 'N')
+          s +=  (@angle < 0 ? 'S' : 'N')
         when 'E'
-          s += (@value < 0 ? 'W' : 'E')
+          s += (@angle < 0 ? 'W' : 'E')
         end
       else
         s += t[1] #the fillers.
@@ -313,37 +347,50 @@ class Angle
   end
   
   private 
-  def s_places(v, places)
+  #Output angle_dec as a string to the number of decimal places specified by places.
+  #Assumes the angle is 0 <= angle_dec < 1
+  #No leading '0' is output. The string starts with a '.'
+  #If ploces is -1, then all decimal places are returned.
+  # @return [String]
+  def s_places(angle_dec, places)
     if places != -1
-      dec_p = (v * 10 ** places).round
-      f = ".%0#{places > 0 ? places : ''}d"
-      f % dec_p
+      places > 0 ? ".%0#{places}d" % (angle_dec * 10 ** places).round : ''
     else
-      '.' + v_dec.to_s[2..-1] 
+      angle_dec.to_s[1..-1] #Output all decimal places stripping the leading 0
     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
+  #return the angle as a string with 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)
+  # @return [String]
+  def s_float(angle, width, places, abs)
+    angle_int, angle_dec = angle.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)
+    s = (abs == false && angle.sign == -1) ? '-' : ''  #catch the case of -0
+    s += f % angle.abs + s_places(angle_dec, places)
   end
 
-  def s_int(v, width, abs)
+  #Return the integer part of angle as a string of fixed width
+  #If abs == true, then return the absolute value.
+  # @return [Fixnum]
+  def s_int(angle, width, abs)
     f = "%0#{width > 0 ? width : ''}d"
-    s = (abs == false && v.sign == -1) ? '-' : ''  #catch the case of -0
-    s += f % v.abs
+    s = (abs == false && angle.sign == -1) ? '-' : ''  #catch the case of -0
+    s += f % angle.abs
+  end
+  
+  #Return the fractional part of angle as a string,
+  #to the number of decimal places specified by 'places'.
+  #No leading '0' is output. The string starts with a '.'
+  #If ploces is -1, then all decimal places are returned.
+  # @return [String]
+  def s_only_places(angle, places)
+    angle_int, angle_dec = angle.abs.divmod(1)
+    s_places(angle_dec, places)
   end
 end
 

data/lib/coordinate.rb

@@ -1,29 +1,34 @@
-#Holds both latitude and longitude, and the altitude at that point
 
 require 'angle.rb'
 
+#Holds the latitude, longitude, and the altitude for the coordinate
 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
+  #latitude and longitude are in degrees unless radians == true (or set to :radians)
   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
   
-  #Should add a format string to this.
   #Returns: Latitude longitude and altitude as a single string.
+  #Should add an optional format string to this.
   def to_s
     "#{@latitude.to_s }  #{@longitude.to_s} #{@altitude}m"
   end
   
+  #Return coordinate as a 3 member array, with
+  #members, latitude, longitude and altitude
   def to_ary
     [ @latitude, @longitude, @altitude ]
   end
   
   alias to_a to_ary
   
+  #return coordinate a 3 member hash with
+  #keys :latitude, :longitude, and :altitude
   def to_hash
     { :latitude => @latitude, :longitude => @longitude, :altitude => @altitude }
   end

data/lib/core_extensions.rb

@@ -13,6 +13,7 @@ class Numeric
       self * 180  / Math::PI 
     end
   end
+  
   #Converts degrees to Radians
   #if optional argument mod == true, then applies % Math::PI
   #Returns: radians
@@ -49,22 +50,22 @@ 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, ...
+  #common forms are S37 001'7.5'', 37 001'7.5''S , -37 001'7.5'', -37 0 1.512'. -37.01875 0, 37 001'.512S, S37 001'.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
+    #reorder 37 001'.512S, S37 001'.512 into 37 001.512'S, S37 001.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 0, 37 0S
     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
+    #add in seconds get 3 values 'deg min 0' from  S37 01.512',  37 01.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°, ...
+    #look for anything of the form S37 001'7.5'', S37 01.512', S37.01875 0, ...
     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°, ...
+    #look for anything of the form 37 001'7.5''S , -37 001'7.5'', -37 0 1.512'. -37.01875 0, ...
     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

data/lib/latitude.rb

@@ -1,12 +1,13 @@
-#Subclass of Angle to add in special treatment of to_d, to_r , to_s
 
 require 'angle.rb'
 
+#Subclass of Angle to add in special treatment of to_d, to_r , to_s
+#Latitude degrees are between -PI and PI, South to North (+/- 90 degrees)
+
 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)
@@ -17,22 +18,20 @@ class Latitude < Angle
     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
+    when @angle > 3*Math::PI/2 ;  @angle - Math::PI * 2
+    when @angle > Math::PI ; Math::PI - @angle
+    when @angle > Math::PI/2 ; Math::PI - @angle
+    when @angle < -Math::PI/2 ; -Math::PI - @angle
+    else @angle
     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')
+  def to_s(fmt="%2d %2m'%2.4s\"%N")
       super(fmt)
   end
   

data/lib/longitude.rb

@@ -1,9 +1,11 @@
-#Subclass of Angle to add in special treatment of to_d, to_r and to_s
 
 require 'angle.rb'
 
+#Subclass of Angle to add in special treatment of to_d, to_r and to_s
+#Longitude degrees are between -2PI and 2PI, West to East (+/- 180 degrees)
+
 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
@@ -13,18 +15,17 @@ class Longitude < Angle
     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
+      when @angle > Math::PI ; @angle - 2 * Math::PI
+      else @angle
     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')
+  def to_s(fmt="%3d %2m'%2.4s\"%E")
     super(fmt)
   end
   

data/lib/track_and_distance.rb

@@ -1,10 +1,11 @@
-#Holds a bearing and distance
 
 require 'angle.rb'
 
+#Holds a bearing and distance
 class TrackAndDistance
     attr_accessor :bearing, :distance
-    #Bearing is in degrees unless radians == true.
+    
+    #Bearing is in degrees unless radians == true (or set to :radians).
     #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)
@@ -23,10 +24,12 @@ class TrackAndDistance
       end
     end
 
+    #Returns an array with members bearing and distance.
     def to_ary
       [ @bearing, @distance ]
     end
     
+    #Returns a hash with keys :bearing and :distance
     def to_hash
       { :bearing => @bearing, :distance => @distance }
     end

data/lib/vincenty.rb

@@ -1,9 +1,3 @@
-#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'
@@ -11,8 +5,14 @@ require 'longitude.rb'
 require 'track_and_distance.rb'
 require 'coordinate.rb'
 
+#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.
 class Vincenty < Coordinate
-  VERSION = '1.0.3'
+  VERSION = '1.0.4'
   
   def version
     VERSION
@@ -24,7 +24,7 @@ class Vincenty < Coordinate
   #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) 
+    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.
     
@@ -52,7 +52,7 @@ class Vincenty < Coordinate
   #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) 
+    a = 6378137 #equatorial radius in meters     (+/-2 m) 
     b = 6356752.31424518 #polar radius in meters
     f = (a-b)/a #  flattening 
    
@@ -67,7 +67,7 @@ class Vincenty < Coordinate
     
       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’
+      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)
@@ -121,7 +121,7 @@ class Vincenty < Coordinate
   #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) 
+    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.
     
@@ -141,10 +141,9 @@ class Vincenty < Coordinate
   #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) 
+    a = 6378137 #equatorial radius in meters     (+/-2 m) 
     b = 6356752.31424518 #polar radius in meters
     f = (a-b)/a #  flattening 
     

data/test/ts_angle.rb

@@ -5,14 +5,14 @@ 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("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)
@@ -20,25 +20,32 @@ class TestAngle< Test::Unit::TestCase
     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)
+    assert_equal(Angle.radians(-0.646099072472651).value, Angle.radians(-0.646099072472651).angle)
+    assert_equal(Angle.decimal_deg(1,2,3,'S'), -(1.0 + 2/60.0 + 3/3600.0))
+    assert_equal(Angle.decimal_deg(1,2,3,'E'), (1.0 + 2/60.0 + 3/3600.0))
+    assert_equal(Angle.decimal_deg(1,2,4,'N'), (1.0 + 2/60.0 + 4/3600.0))
+    assert_equal(Angle.decimal_deg(1,5,4,'W'), -(1.0 + 5/60.0 + 4/3600.0))
+    assert_equal(Angle.decimal_deg_from_ary([1,5,4,'W']), -(1.0 + 5/60.0 + 4/3600.0))
+    assert_equal(Angle.decimal_deg_from_ary(Angle.dms( -(1.0 + 5/60.0 + 1.0/3600.0) )),-(1.0 + 5/60.0 + 1.0/3600.0)) #double call, rounding error always produced a failure.
   end
   
   def test_strf
-    a = Angle.new("S37°01′7.5″")
-    assert_equal("-37°01′07.5000″", a.strf) #default format of strf
-    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°" ))
+    a = Angle.new("S37 01'7.5\"")
+    assert_equal("-37 01'07.5000\"", a.strf) #default format of strf
+    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
+    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

data/test/ts_coordinate.rb

@@ -13,6 +13,6 @@ class TestAngle< Test::Unit::TestCase
     assert_equal(-36.9923293459124, ch[:latitude].to_d)
     assert_equal(174.485341187381, ch[:longitude].to_d)
     assert_equal(13.5, ch[:altitude])
-    assert_equal("36°59′32.3856″S  174°29′07.2283″E 13.5m", c.to_s)
+    assert_equal("36 59'32.3856\"S  174 29'07.2283\"E 13.5m", c.to_s)
   end
 end

data/test/ts_latitude.rb

@@ -3,12 +3,12 @@ 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)
+    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)

data/test/ts_longitude.rb

@@ -3,12 +3,12 @@ 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)
+    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)

data/test/ts_track_and_distance.rb

@@ -4,13 +4,13 @@ require 'vincenty.rb'
 class TestAngle< Test::Unit::TestCase
   #test TrackAndDistance
   def test_track_and_distance
-    assert_equal("140°14′10.0000″ 12.0m", TrackAndDistance.new(Angle.new("320,14,10").reverse, 12.0).to_s)
-    assert_equal("215°03′00.0000″ 19.73m", TrackAndDistance.new("215,3,0", 19.73 ).to_s)
+    assert_equal("140 14'10.0000\" 12.0m", TrackAndDistance.new(Angle.new("320,14,10").reverse, 12.0).to_s)
+    assert_equal("215 03'00.0000\" 19.73m", TrackAndDistance.new("215,3,0", 19.73 ).to_s)
     a = TrackAndDistance.new("215,3,0", 19.73 ).to_ary
-    assert_equal("215°03′00.0000″", a[0].strf)
+    assert_equal("215 03'00.0000\"", a[0].strf)
     assert_equal("19.73", a[1].to_s)
     a = TrackAndDistance.new("215,3,0", 19.73 ).to_hash
-    assert_equal("215°03′00.0000″", a[:bearing].strf)
+    assert_equal("215 03'00.0000\"", a[:bearing].strf)
     assert_equal("19.73", a[:distance].to_s)
   end
 end

data/test/ts_vincenty.rb

@@ -82,13 +82,13 @@ class TestVincenty< Test::Unit::TestCase
   
   #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
+    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(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))
+    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

metadata

@@ -1,32 +1,82 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: vincenty
-version: !ruby/object:Gem::Version 
-  version: 1.0.3
+version: !ruby/object:Gem::Version
+  version: 1.0.4
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Rob Burrowes
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-12-31 00:00:00 +13:00
-default_executable: 
-dependencies: 
-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
+date: 2013-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hoe-yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: ! "* Vincenty wrote an algorithm for calculating the bearing and distance
+  between two coordinates on the earth\n  and an algorithm for finding a second coordinate,
+  given a starting coordinate, bearing and destination.\n  The algorithms model the
+  earth as an ellipsoid, using the WGS-84 model. This is the common GPS model for\n
+  \ mapping to latitudes and longitudes.\n\n  This is a Ruby implementation of Vincenty's
+  algorithms, and the Vincenty class includes two methods for \n  modeling the earth
+  as a sphere. These were added as a reference for testing the Vincenty algorithm,
+  but\n  could be used on their own. \n\n  The package also makes use of several other
+  classes that may be useful in their own Right. These include\n  class Angle, class
+  Latitude (subclass of Angle), class Longitude (subclass of Angle), \n  class TrackAndBearing
+  and class coordinate (which class Vincenty is a subclass)\n\n  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.\n\n*  The Vincenty code is based
+  on the wikipedia presentation of the Vincenty algorithm http://en.wikipedia.org/wiki/Vincenty%27s_formulae
+  .\n*  The algorithm was modified to include changes I found at http://www.movable-type.co.uk/scripts/latlong-vincenty-direct.html.\n*
+  \ I also altered the formulae to correctly return the bearing for angles greater
+  than 180. \n  \n* Vincenty's original publication\n\n** 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:
+- r.burrowes@auckland.ac.nz
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - History.txt
 - Manifest.txt
-- README.txt
-files: 
+files:
 - History.txt
 - Manifest.txt
-- README.txt
+- README.md
 - Rakefile
 - lib/angle.rb
 - lib/coordinate.rb
@@ -42,34 +92,37 @@ files:
 - test/ts_vincenty.rb
 - test/ts_coordinate.rb
 - test/ts_track_and_distance.rb
-has_rdoc: true
-homepage: http://rubyforge.org/projects/vincenty/
+- .gemtest
+homepage: http://rbur004.github.com/vincenty/
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --main
-- README.txt
-require_paths: 
+rdoc_options:
+- --markup
+- markdown
+- --protected
+- --title
+- Vincenty
+- --quiet
+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: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: vincenty
-rubygems_version: 1.3.5
+rubygems_version: 1.8.24
 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"
+specification_version: 3
+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: []
-