vincenty 1.0.4 → 1.0.9

data/lib/vincenty.rb

@@ -1,191 +1,201 @@
-require 'core_extensions.rb'
-require 'angle.rb'
-require 'latitude.rb'
-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.
+require_relative 'core_extensions.rb'
+require_relative 'angle.rb'
+require_relative 'latitude.rb'
+require_relative 'longitude.rb'
+require_relative 'track_and_distance.rb'
+require_relative '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.4'
-  
+  VERSION = '1.0.9'
+
+  # @return [String] constant VERSION
   def version
     VERSION
   end
-  
-  #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)
+
+  WGS84_ER = 6378137              # Equatorial Radius of earth
+  WGS84_IF = 298.257223563        # Inverse Flattening
+  GRS80_ER = 6378137              # Equatorial Radius of earth
+  GRS80_IF = 298.25722210882711   # Inverse Flattening
+
+  # 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.
+  # @param [Coordinate] p2 is target coordinate that we want the bearing to.
+  # @return [TrackAndDistance]  with the compass bearing and distance in meters to P2
+  def sphericalDistanceAndAngle( p2, equatorial_radius = WGS84_ER, inverse_flattening = WGS84_IF )
+    if self.latitude == p2.latitude && self.longitude == p2.longitude
+      return TrackAndDistance.new(0, 0, true) # No calculations necessary
+    end
+
+    a = equatorial_radius # equatorial radius in meters     (+/-2 m)
+    f = inverse_flattening
+    b = a - a / f # WGS84 = 6356752.314245179 polar radius in meters
+    r = (a + b) / 2 # average diametre as a rough estimate for our tests.
+
+    sin_lat1 = Math.sin(@latitude.to_rad)
+    sin_lat2 = Math.sin(p2.latitude.to_rad)
+    cos_lat1 = Math.cos(@latitude.to_rad)
     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.
+    t1 = cos_lat1 * Math.cos(p2.latitude.to_rad) * Math.cos(@longitude.to_rad - p2.longitude.to_rad) + 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
+    bearing = if Math.sin(p2.longitude.to_rad - @longitude.to_rad) < 0
+                2 * Math::PI - (Math.atan(-t2 / Math.sqrt(-t2 * t2 + 1)) + atan1_2) # Compass Bearing in radians (clockwise)
+              else
+                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. 
+    # 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
+  # Vincenty's algorithm for finding bearing and distance between to coordinates.
+  # Assumes earth is a WGS-84 Ellipsod.
+  # @param [Coordinate] p2 is target coordinate that we want the bearing to.
+  # @return [TrackAndDistance] with the compass bearing and distance in meters to P2
   def distanceAndAngle( p2 )
+    if self.latitude == p2.latitude && self.longitude == p2.longitude
+      return TrackAndDistance.new(0, 0, true) # No calculations necessary. Solv NAN issue
+    end
+
     # 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
+    a = 6378137 # equatorial radius in meters     (+/-2 m)
+    b = 6356752.31424518 # polar radius in meters
+    f = (a - b) / a #  flattening
+
+    lat1 = @latitude.to_rad
+    lon1 = @longitude.to_rad
+    lat2 = p2.latitude.to_rad
+    lon2 = p2.longitude.to_rad
+    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)
+    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)
-      
-      #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)
+      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
-  
-    #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
+
+    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.
+    alpha_1 = if Math.sin(p2.longitude.to_rad - @longitude.to_rad) < 0
+                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
+                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.
+  # spherical earth estimate of calculation for finding target coordinate from start coordinate, bearing and distance
+  # Used to run checks on the Vincenty algorithm
+  # @param [TrackAndDistance] track_and_distance specifying  bearing and distance.
+  # @return [Vincenty]  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.
-    
+    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);
+    sin_dor = Math.sin(d / r)
+    cos_dor = Math.cos(d / r)
+    sin_lat1 = Math.sin(@latitude.to_rad)
+    cos_lat1 = Math.cos(@latitude.to_rad)
+    lat2 = Math.asin( sin_lat1 * cos_dor + cos_lat1 * sin_dor * Math.cos(track_and_distance.bearing.to_rad) )
+    lon2 = @longitude.to_rad + Math.atan2(Math.sin(track_and_distance.bearing.to_rad) * 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 ) 
+  # Assumes earth is a WGS-84 Ellipsod.
+  # @param [TrackAndDistance]  specifying bearing and distance.
+  # @return [Vincenty] 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
+    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_rad
     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))
+
+    tanU1 = (1 - f) * Math.tan(@latitude.to_rad)
+    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)))
-  
+    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)
+    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)))
+      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
+      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))
+    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
+    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

@@ -1,10 +1,10 @@
-require 'ts_angle.rb'
-require 'ts_vincenty.rb'
-require 'ts_latitude.rb'
-require 'ts_longitude.rb'
-require 'ts_coordinate.rb'
-require 'ts_track_and_distance.rb'
+#!/usr/bin/env ruby
+require_relative 'ts_angle.rb'
+require_relative 'ts_vincenty.rb'
+require_relative 'ts_latitude.rb'
+require_relative 'ts_longitude.rb'
+require_relative 'ts_coordinate.rb'
+require_relative 'ts_track_and_distance.rb'
 
+puts 'Testing from source'
 puts Vincenty.new.version
-
-

data/test/ts_angle.rb

@@ -1,81 +1,82 @@
+#!/usr/bin/env ruby
 require 'test/unit'
-require 'vincenty.rb'
+require_relative '../lib/vincenty.rb'
 
-class TestAngle< Test::Unit::TestCase
-  #test Angle creation
+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)
+    assert_equal(Angle.new, 0)
+    assert_equal(Angle.new("S37 01'7.5\"").to_deg, -37.01875) # Leading NSEW
+    assert_equal(Angle.new("37 01'7.5\"S").to_deg, -37.01875) # Trailing NSEW
+    assert_equal(Angle.new("-37 01'7.5\"").to_deg, -37.01875) # Use of - rather than S or W
+    assert_equal(Angle.new("-37  1.125'").to_deg, -37.01875) # Decimal minutes, rather than minutes and seconds.
+    assert_equal(Angle.new("-37 01'.125").to_deg, -37.01875) # Nb. the minute marker ' between the minutes and fraction
+    assert_equal(Angle.new("S37 01'.125").to_deg, -37.01875) # Nb. the minute marker ' between the minutes and fraction
+    assert_equal(Angle.new("37 01'.125S").to_deg, -37.01875) # Nb. the minute marker ' between the minutes and fraction
+    assert_equal(Angle.new('-37.01875 ').to_deg, -37.01875) # decimal degrees, rather than deg, min, sec.
+    assert_equal(Angle.new([ -37, 1, 7.5 ]).to_deg, -37.01875) # an array of deg,min,sec
+    assert_equal(Angle.new(-37.01875).to_deg, -37.01875)
+    assert_equal(Angle.degrees(-37.01875).to_deg, -37.01875)
+    assert_equal(Angle.degrees(-37.01875).to_rad.round(15), -0.646099072472651)
+    assert_equal(Angle.new(-0.646099072472651, true).to_deg.round(5), -37.01875)
+    assert_equal(Angle.new(-0.646099072472651, true).to_rad, -0.646099072472651)
+    assert_equal(Angle.radians(-0.646099072472651).to_deg.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.
+    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.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("*** -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
-    #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) # /
+    # 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(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.
+    # 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
+    # abs
     assert_equal(3, Angle.radians(-3).abs)
-    #reverse
+    # reverse
     assert_equal(Angle.degrees(90), Angle.degrees(270).reverse)
-    #bearing
+    # bearing
     assert_equal(Angle.degrees(340), Angle.degrees(20).to_bearing)
   end
-end
+end

data/test/ts_coordinate.rb

@@ -1,18 +1,19 @@
+#!/usr/bin/env ruby
 require 'test/unit'
-require 'vincenty.rb'
+require_relative '../lib/vincenty.rb'
 
-class TestAngle< Test::Unit::TestCase
-  #test Coordinate
+class TestCoordinate < Test::Unit::TestCase
+  # test Coordinate
   def test_coordinate
-    c = Coordinate.new(-36.9923293459124, 174.485341187381,13.5)
+    c = Coordinate.new(-36.9923293459124, 174.485341187381, 13.5)
     ca = c.to_ary
-    assert_equal(-36.9923293459124, ca[0].to_d)
-    assert_equal(174.485341187381, ca[1].to_d)
+    assert_equal(-36.9923293459124, ca[0].to_deg)
+    assert_equal(174.485341187381, ca[1].to_deg)
     assert_equal(13.5, ca[2])
     ch = c.to_hash
-    assert_equal(-36.9923293459124, ch[:latitude].to_d)
-    assert_equal(174.485341187381, ch[:longitude].to_d)
+    assert_equal(-36.9923293459124, ch[:latitude].to_deg)
+    assert_equal(174.485341187381, ch[:longitude].to_deg)
     assert_equal(13.5, ch[:altitude])
     assert_equal("36 59'32.3856\"S  174 29'07.2283\"E 13.5m", c.to_s)
   end
-end
+end

data/test/ts_latitude.rb

@@ -1,7 +1,8 @@
+#!/usr/bin/env ruby
 require 'test/unit'
-require 'vincenty.rb'
+require_relative '../lib/vincenty.rb'
 
-class TestAngle< Test::Unit::TestCase
+class TestLatitude < 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)
@@ -10,22 +11,24 @@ class TestAngle< Test::Unit::TestCase
     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)
+    assert_equal(Math::PI / 4, Latitude.degrees(45).to_rad)
+    assert_equal(Math::PI / 4, Latitude.degrees(135).to_rad)
+    assert_equal(-Math::PI / 4, Latitude.degrees(225).to_rad)
+    assert_equal(-Math::PI / 4, Latitude.degrees(315).to_rad)
   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)
+    assert_equal(45, Latitude.degrees(45).to_deg)
+    assert_equal(45, Latitude.degrees(135).to_deg)
+    assert_equal(-45, Latitude.degrees(225).to_deg)
+    assert_equal(-45, Latitude.degrees(315).to_deg)
+    assert_equal(1, Latitude.degrees(179).to_deg)
+    assert_equal(-1, Latitude.degrees(181).to_deg)
+    assert_equal(-89, Latitude.degrees(269).to_deg)
+    assert_equal(-89, Latitude.degrees(271).to_deg)
+    assert_equal(89, Latitude.degrees(89).to_deg)
+    assert_equal(89, Latitude.degrees(91).to_deg)
   end
-end
+end

data/test/ts_longitude.rb

@@ -1,7 +1,8 @@
+#!/usr/bin/env ruby
 require 'test/unit'
-require 'vincenty.rb'
+require_relative '../lib/vincenty.rb'
 
-class TestAngle< Test::Unit::TestCase
+class TestLongitude < 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)
@@ -10,16 +11,18 @@ class TestAngle< Test::Unit::TestCase
     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)
+    assert_equal(Math::PI / 4, Longitude.degrees(45).to_rad)
+    assert_equal(3 * Math::PI / 4, Longitude.degrees(135).to_rad)
+    assert_equal(-3 * Math::PI / 4, Longitude.degrees(225).to_rad)
+    assert_equal(-Math::PI / 4, Longitude.degrees(315).to_rad)
   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)
+    assert_equal(45, Longitude.degrees(45).to_deg)
+    assert_equal(135, Longitude.degrees(135).to_deg)
+    assert_equal(-135, Longitude.degrees(225).to_deg)
+    assert_equal(-45, Longitude.degrees(315).to_deg)
   end
-end
+end