vincenty 1.0.8 → 1.0.9

data/test/ts_all.rb

@@ -6,5 +6,5 @@ require_relative 'ts_longitude.rb'
 require_relative 'ts_coordinate.rb'
 require_relative 'ts_track_and_distance.rb'
 
-puts "Testing from source"
+puts 'Testing from source'
 puts Vincenty.new.version

data/test/ts_angle.rb

@@ -1,19 +1,20 @@
+#!/usr/bin/env ruby
 require 'test/unit'
 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_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, 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)
@@ -21,61 +22,61 @@ class TestAngle< Test::Unit::TestCase
     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

data/test/ts_coordinate.rb

@@ -1,10 +1,11 @@
+#!/usr/bin/env ruby
 require 'test/unit'
 require_relative '../lib/vincenty.rb'
 
-class TestCoordinate< 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_deg)
     assert_equal(174.485341187381, ca[1].to_deg)

data/test/ts_latitude.rb

@@ -1,7 +1,8 @@
+#!/usr/bin/env ruby
 require 'test/unit'
 require_relative '../lib/vincenty.rb'
 
-class TestLatitude< 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,12 +11,14 @@ class TestLatitude< 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_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)
+    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_deg)
     assert_equal(45, Latitude.degrees(135).to_deg)

data/test/ts_longitude.rb

@@ -1,7 +1,8 @@
+#!/usr/bin/env ruby
 require 'test/unit'
 require_relative '../lib/vincenty.rb'
 
-class TestLongitude< 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,12 +11,14 @@ class TestLongitude< 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_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)
+    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_deg)
     assert_equal(135, Longitude.degrees(135).to_deg)

data/test/ts_track_and_distance.rb

@@ -1,19 +1,19 @@
+#!/usr/bin/env ruby
 require 'test/unit'
 require_relative '../lib/vincenty.rb'
 
-class TestTrackAndDistance< Test::Unit::TestCase
-  #test TrackAndDistance
+class TestTrackAndDistance < 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
+    a = TrackAndDistance.new('215,3,0', 19.73 ).to_ary
     assert_equal("215 03'00.0000\"", a[0].strf)
-    assert_equal("19.73", a[1].to_s)
+    assert_equal('19.73', a[1].to_s)
 
-    a = TrackAndDistance.new("215,3,0", 19.73 ).to_hash
+    a = TrackAndDistance.new('215,3,0', 19.73 ).to_hash
     assert_equal("215 03'00.0000\"", a[:bearing].strf)
-    assert_equal("19.73", a[:distance].to_s)
-
+    assert_equal('19.73', a[:distance].to_s)
   end
 end

data/test/ts_vincenty.rb

@@ -1,86 +1,87 @@
+#!/usr/bin/env ruby
 require 'test/unit'
 require_relative '../lib/vincenty.rb'
 
-class TestVincenty< Test::Unit::TestCase
-
+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 ),
+    @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),
+      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).
+  # 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_deg}, #{next_p.latitude.to_deg}\n"
-    @path.each_with_index do |leg,i|
-      next_p, spherical_ans = next_p.destination( leg ) , next_p.sphereDestination(leg)
+    #    print "Start at coordinate #{next_p.longitude.to_deg}, #{next_p.latitude.to_deg}\n"
+    @path.each_with_index do |leg, i|
+      spherical_ans = next_p.sphereDestination(leg)
+      next_p = next_p.destination( leg )
 
       assert_equal(@waypoints[i].longitude.to_deg.round(12), next_p.longitude.to_deg.round(12))
       assert_equal(@waypoints[i].latitude.to_deg.round(12), next_p.latitude.to_deg.round(12))
-  #    print "Expect  #{waypoints[i].longitude.to_deg.round(4)}, #{waypoints[i].latitude.to_deg.round(4)}\n"
-  #    print "Moved #{leg.bearing.to_deg.round(4)} #{leg.distance.round(4)}m to #{next_p.longitude.to_deg.round(4)}, #{next_p.latitude.to_deg.round(4)}\n"
-  #    print "Spherical #{leg.bearing.to_deg.round(4)} #{leg.distance.round(4)}m to #{spherical_ans.longitude.to_deg.round(4)}, #{spherical_ans.latitude.to_deg.round(4)}\n"
-  #    puts
+      #    print "Expect  #{waypoints[i].longitude.to_deg.round(4)}, #{waypoints[i].latitude.to_deg.round(4)}\n"
+      #    print "Moved #{leg.bearing.to_deg.round(4)} #{leg.distance.round(4)}m to #{next_p.longitude.to_deg.round(4)}, #{next_p.latitude.to_deg.round(4)}\n"
+      #    print "Spherical #{leg.bearing.to_deg.round(4)} #{leg.distance.round(4)}m to #{spherical_ans.longitude.to_deg.round(4)}, #{spherical_ans.latitude.to_deg.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)}"
+    #  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.
+  # 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_deg}, #{next_p.latitude.to_deg}\n"
-    @waypoints.each_with_index do |point,i|
+    #   print "\nReverse test, c\n"
+    #    print "Start at coordinate #{next_p.longitude.to_deg}, #{next_p.latitude.to_deg}\n"
+    @waypoints.each_with_index do |point, i|
       vtrack_and_bearing = next_p.distanceAndAngle( point )
-  #    strack_and_bearing = next_p.sphericalDistanceAndAngle( point )
+      #    strack_and_bearing = next_p.sphericalDistanceAndAngle( point )
 
       assert_equal(@path[i].bearing.to_deg.round(4), vtrack_and_bearing.bearing.to_deg.round(4))
       assert_equal(@path[i].distance.round(4), vtrack_and_bearing.distance.round(4))
-  #    print "Expected #{path[i].bearing.to_deg.round(4)}(#{((path[i].bearing.to_deg+180)%360).round(4)}), #{path[i].distance.round(4)}m\n"
-  #    print "WGS-84 track #{vtrack_and_bearing.bearing.to_deg.round(4)} #{vtrack_and_bearing.distance.round(4)}m from #{next_p.longitude.to_deg.round(4)}, #{next_p.latitude.to_deg.round(4)} to #{point.longitude.to_deg.round(4)},  #{point.latitude.to_deg.round(4)}\n"
-  #    print "Spherical track #{strack_and_bearing.bearing.to_deg.round(4)} #{strack_and_bearing.distance.round(4)}m from #{next_p.longitude.to_deg.round(4)}, #{next_p.latitude.to_deg.round(4)} to #{point.longitude.to_deg.round(4)},  #{point.latitude.to_deg.round(4)}\n"
-  #    puts
+      #    print "Expected #{path[i].bearing.to_deg.round(4)}(#{((path[i].bearing.to_deg+180)%360).round(4)}), #{path[i].distance.round(4)}m\n"
+      #    print "WGS-84 track #{vtrack_and_bearing.bearing.to_deg.round(4)} #{vtrack_and_bearing.distance.round(4)}m from #{next_p.longitude.to_deg.round(4)}, #{next_p.latitude.to_deg.round(4)} to #{point.longitude.to_deg.round(4)},  #{point.latitude.to_deg.round(4)}\n"
+      #    print "Spherical track #{strack_and_bearing.bearing.to_deg.round(4)} #{strack_and_bearing.distance.round(4)}m from #{next_p.longitude.to_deg.round(4)}, #{next_p.latitude.to_deg.round(4)} to #{point.longitude.to_deg.round(4)},  #{point.latitude.to_deg.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"
+    # assert_equal(0, next_p.distanceAndAngle(start).distance)
+    #  puts "distance from end to start should be 0. Actual #{next_p.distanceAndAngle(start)}\n"
   end
 
-  #Edge case, when points are at same location
+  # Edge case, when points are at same location
   def test_vincenty_distance_and_angle_when_0
     start = Vincenty.new(-36.9921838030711, 174.485468469841)
     vtrack_and_bearing = start.distanceAndAngle( start )
@@ -89,10 +90,10 @@ class TestVincenty< Test::Unit::TestCase
     assert_equal(0, vtrack_and_bearing.distance.round(4))
   end
 
-  #Run the Australian Geoscience site example.
+  # 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
+    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_deg.round(4), track_and_bearing.bearing.to_deg.round(4))
     assert_equal(54972.271, track_and_bearing.distance.round(3))
@@ -101,5 +102,4 @@ class TestVincenty< Test::Unit::TestCase
     assert_equal(buninyong.latitude.to_deg.round(4), destination.latitude.to_deg.round(4))
     assert_equal(buninyong.longitude.to_deg.round(4), destination.longitude.to_deg.round(4))
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vincenty
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.0.9
 platform: ruby
 authors:
 - Rob Burrowes
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-12-03 00:00:00.000000000 Z
+date: 2021-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hoe-yard
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.1.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: hoe
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.15'
+        version: '3.23'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.15'
+        version: '3.23'
 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
@@ -88,17 +88,17 @@ files:
 - test/ts_longitude.rb
 - test/ts_track_and_distance.rb
 - test/ts_vincenty.rb
-homepage: http://rbur004.github.com/vincenty/
+homepage: http://rbur004.github.io/vincenty/
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--markup"
 - markdown
 - "--protected"
 - "--title"
-- Vincenty
+- vincenty
 - "--quiet"
 require_paths:
 - lib
@@ -113,9 +113,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 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