vincenty 1.0.8 → 1.0.9

data/lib/core_extensions.rb

@@ -1,99 +1,97 @@
 require 'scanf'
 
-#Extends Numeric, hence Fixed & Float to_r & to_d
-#Also adds in sign.
+# Extends Numeric, hence Fixed & Float to_r & to_d
+# Also adds in sign.
 class Numeric
-  #Convert Radians to Degrees
+  # Convert Radians to Degrees
   # @return [Numeric] degrees
   # @param [true,false]  mod Optional argument mod == true, then applies % 360
-  def to_degrees(mod=false) 
-    if mod 
-      (self * 180  / Math::PI) % 360
-    else 
-      self * 180  / Math::PI 
+  def to_degrees(mod = false)
+    if mod
+      (self * 180 / Math::PI) % 360
+    else
+      self * 180 / Math::PI
     end
   end
-  
-  #Converts degrees to Radians
+
+  # Converts degrees to Radians
   # @return [Numeric] radians
   # @param [true,false] mod Optional argument mod == true, then applies % Math::PI
-  def to_radians(mod=false)
-    if mod 
+  def to_radians(mod = false)
+    if mod
       (self * Math::PI / 180) % Math::PI
-    else 
+    else
       self * Math::PI / 180
     end
   end
-  
+
   alias to_r to_radians
   alias to_rad to_radians
   alias to_deg to_degrees
-  
+
   # @return [Fixnum] 1 if number is positive, -1 if negative.
   def sign
     self < 0 ? -1 : 1
   end
-    
 end
 
-#Alters round method to have an optional number of decimal places.
+# Alters round method to have an optional number of decimal places.
 class Float
-  
-  #Replace default round, so we can reference it later.
+  # Replace default round, so we can reference it later.
   # @return [Float]
   alias round0 round
-  
-  #Compatible Replacement for Float.round
+
+  # Compatible Replacement for Float.round
   # @return [Float] float rounded to n decimal places.
   # @param [Numeric] n Optional argument n is the number of decimal places to round to.
   def round(n = 0)
     if n == 0
-      self.round0 #This is to preserve the default behaviour, which is to return a Fixnum, not a float.
+      self.round0 # This is to preserve the default behaviour, which is to return a Fixnum, not a float.
     else
       m = 10.0**n
-     (self *  m).round0 / m
-   end
+      (self * m).round0 / m
+    end
   end
 end
 
-#Extends String to to_dec_degrees, add to_r and to_d
+# 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 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, ...
+  # string expected to be degrees, returns decimal degrees.
+  # 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, ...
   # @return [Float] angle in decimal degrees
-  def to_dec_degrees 
-    #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 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 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|
+  def to_dec_degrees
+    # 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 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 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 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|
+
+    # 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
   end
-  
-  #Convert String number in Radians to Degrees
+
+  # Convert String number in Radians to Degrees
   # @return [Float]  degrees
   # @param [true,false] mod Optional argument mod == true, then applies % 360
-  def to_degrees(mod=false) #string expected to be radians, returns degrees
-    self.to_f.to_degrees(mod)
+  def to_degrees(mod = false)
+    return self.to_f.to_degrees(mod)
   end
-  
-  #Converts string degrees to to_decimal_degrees, then to Radians
+
+  # Converts string degrees to to_decimal_degrees, then to Radians
   # @return [Float] radians
   # @param [true,false] mod Optional argument mod == true, then applies % Math::PI
-  def to_radians(mod=false) #string expected to be degrees, returns radians
-    self.to_dec_degrees.to_radians(mod)
+  def to_radians(mod = false)
+    return self.to_dec_degrees.to_radians(mod)
   end
-  
+
   alias to_rad to_radians
   alias to_r to_radians
   alias to_deg to_degrees

data/lib/latitude.rb

@@ -1,44 +1,42 @@
-
 require_relative '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)
-
+# 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
-
   # @return [Float] angle as degrees in range -90 and 90
   def to_degrees
     degrees = super
-    case
-    when degrees > 270 ; -(360 - degrees)
-    when degrees > 180 ; 180 - degrees
-    when degrees > 90 ; 180 - degrees
-    when degrees < -90 ; 180 - degrees
-    else degrees
+    if degrees > 270
+      -(360 - degrees)
+    elsif degrees > 180 || degrees > 90 || degrees < -90
+      180 - degrees
+    else
+      degrees
     end
   end
 
   # @return [Float] angle as degrees in range -PI and PI
   def to_radians
-    case
-    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
+    if @angle > 3 * Math::PI / 2
+      @angle - Math::PI * 2
+    elsif @angle > Math::PI || @angle > Math::PI / 2
+      Math::PI - @angle
+    elsif @angle < -Math::PI / 2
+      -Math::PI - @angle
+    else
+      @angle
     end
   end
 
   # @return [String] angle as string in degrees minutes seconds direction.
-  #A South angle is negative, North is Positive.
+  # A South angle is negative, North is Positive.
   # @param [String] fmt Optional format string passed to Angle#to_s
-  def to_s(fmt="%2d %2m'%2.4s\"%N")
-      super(fmt)
+  def to_s(fmt = "%2d %2m'%2.4s\"%N")
+    super(fmt)
   end
 
   alias to_r to_radians
   alias to_rad to_radians
-  #alias to_d to_degrees
+  # alias to_d to_degrees
   alias to_deg to_degrees
-
 end

data/lib/longitude.rb

@@ -1,38 +1,34 @@
-
 require_relative '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)
-
+# 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
-
   # @return [Float] angle as degrees in range -180 and 180
   def to_degrees
     degrees = super
-    case
-      when degrees > 180 ; degrees - 360
-      else degrees
+    if degrees > 180 then degrees - 360
+    else
+      degrees
     end
   end
 
   # @return [Float] angle as degrees in range -2PI and 2PI
   def to_radians
-    case
-      when @angle > Math::PI ; @angle - 2 * Math::PI
-      else @angle
+    if @angle > Math::PI then @angle - 2 * Math::PI
+    else
+      @angle
     end
   end
 
   # @return [String] angle as string in degrees minutes seconds direction.
-  #A West angle is negative, East is Positive.
+  # A West angle is negative, East is Positive.
   # @param [String] fmt Optional format string passed to Angle#to_s
-  def to_s(fmt="%3d %2m'%2.4s\"%E")
+  def to_s(fmt = "%3d %2m'%2.4s\"%E")
     super(fmt)
   end
 
   alias to_r to_radians
   alias to_rad to_radians
-  #alias to_d to_degrees
+  # alias to_d to_degrees
   alias to_deg to_degrees
-
 end

data/lib/track_and_distance.rb

@@ -1,41 +1,40 @@
-
 require_relative 'angle.rb'
 
-#Holds a bearing and distance
+# Holds a bearing and distance
 class TrackAndDistance
-    # @return [Angle]
-    attr_accessor :bearing
-    # @return [Float]
-    attr_accessor :distance
+  # @return [Angle]
+  attr_accessor :bearing
+  # @return [Float]
+  attr_accessor :distance
 
-    # @param [String, Numeric, #to_radian, #to_f] Bearing can be a String or Numeric or any object with to_radians and to_f
-    # @param [Numeric] distance
-    # @param [true,false, :radians] radians Bearing is in degrees unless radians == true (or set to :radians).
-    def initialize(bearing, distance, radians=false)
-      @bearing = Angle.new(bearing, radians)
-      @distance = distance
-    end
+  # @param [String, Numeric, #to_radian, #to_f] Bearing can be a String or Numeric or any object with to_radians and to_f
+  # @param [Numeric] distance
+  # @param [true,false, :radians] radians Bearing is in degrees unless radians == true (or set to :radians).
+  def initialize(bearing, distance, radians = false)
+    @bearing = Angle.new(bearing, radians)
+    @distance = distance
+  end
 
-    #format string fmt is currently just for the bearing angle.
-    #Need to change this to include the distance is single format string.
-    # @return [String] Bearing angle and distance in meters.
-    # @param [String] fmt Optional format string passed to Coordinate#strf
-    def to_s(fmt = nil)
-      if(fmt)
-        #needs work to include distance as well as angle fmt.
-        "#{@bearing.strf(fmt)} #{distance.round(4)}m"
-      else
-        "#{@bearing.strf} #{distance.round(4)}m"
-      end
+  # format string fmt is currently just for the bearing angle.
+  # Need to change this to include the distance is single format string.
+  # @return [String] Bearing angle and distance in meters.
+  # @param [String] fmt Optional format string passed to Coordinate#strf
+  def to_s(fmt = nil)
+    if fmt
+      # needs work to include distance as well as angle fmt.
+      return "#{@bearing.strf(fmt)} #{distance.round(4)}m"
+    else
+      return "#{@bearing.strf} #{distance.round(4)}m"
     end
+  end
 
-    # @return [Array] with members bearing and distance.
-    def to_ary
-      [ @bearing, @distance ]
-    end
+  # @return [Array] with members bearing and distance.
+  def to_ary
+    return [ @bearing, @distance ]
+  end
 
-    # @return [Hash] with keys :bearing and :distance
-    def to_hash
-      { :bearing => @bearing, :distance => @distance }
-    end
+  # @return [Hash] with keys :bearing and :distance
+  def to_hash
+    return { bearing: @bearing, distance: @distance }
+  end
 end

data/lib/vincenty.rb

@@ -5,199 +5,197 @@ 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.
+# 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.8'
+  VERSION = '1.0.9'
 
   # @return [String] constant VERSION
   def version
     VERSION
   end
 
-  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
+  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.
+  # 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
+      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.
+    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_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.
+    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_rad - @longitude.to_rad) < 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.
+  # 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
+      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
+    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 = @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_rad - @longitude.to_rad) < 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
+    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?
+    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
+  # 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_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))
+    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);
+    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.
+  # 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
+    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;
+    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_rad);
-    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
+    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
+    # sigma2 = Math.atan2(sin_alpha, -tmp)  # reverse azimuth
 
-    return Vincenty.new(lat2, @longitude + l, 0, true);
+    return Vincenty.new(lat2, @longitude + l, 0, true)
   end
-
-
 end