pygeodesy 24.6.9__py2.py3-none-any.whl → 24.7.7__py2.py3-none-any.whl

pygeodesy/rhumb/bases.py

@@ -52,11 +52,11 @@ from pygeodesy.vector3d import _intersect3d3, Vector3d  # in .Intersection below
 from math import cos, fabs
 
 __all__ = ()
-__version__ = '24.05.29'
+__version__ = '24.06.18'
 
 _anti_ = _Dash('anti')
 _rls   = []  # instances of C{RbumbLine...} to be updated
-_TRIPS = 65  # .Intersection, .PlumbTo, 19+
+_TRIPS =  129  # .Intersection, .PlumbTo, 19+
 
 
 class _Lat(Lat):
@@ -716,7 +716,7 @@ class RhumbLineBase(_CapsBase):
                 t = _xTMr(v.x, v.y, lon0=p.lon)  # PYCHOK Reverse4Tuple
                 d = _diff(t.lon - p.lon, t.lat)  # PYCHOK t.lat + p.lat - p.lat
                 p = _LL2T(t.lat + p.lat, t.lon)  # PYCHOK t.lon + p.lon = lon0
-                if d < tol:  # 19 trips
+                if d < tol:  # 19+ trips
                     break
             else:
                 raise ValueError(Fmt.no_convergence(d, tol))
@@ -724,7 +724,7 @@ class RhumbLineBase(_CapsBase):
             P = GDict(lat1=self.lat1, lat2=p.lat, lat0=other.lat1,
                       lon1=self.lon1, lon2=p.lon, lon0=other.lon1,
                       name=_dunder_nameof(self.Intersection, self.name))
-            r = self.Inverse( p.lat, p.lon, outmask=Caps.DISTANCE)
+            r =  self.Inverse(p.lat, p.lon, outmask=Caps.DISTANCE)
             t = other.Inverse(p.lat, p.lon, outmask=Caps.DISTANCE)
             P.set_(azi12= self.azi12, a12=r.a12, s12=r.s12,
                    azi02=other.azi12, a02=t.a12, s02=t.s12,
@@ -824,9 +824,9 @@ class RhumbLineBase(_CapsBase):
            @kwarg exact: If C{None}, use a rhumb line perpendicular to this rhumb line,
                          otherwise use an I{exact} C{Geodesic...} from the given point
                          perpendicular to this rhumb line (C{bool} or C{Geodesic...}),
-                         see method L{Ellipsoid.geodesic_}.
-           @kwarg eps: Optional tolerance for L{pygeodesy.intersection3d3} (C{EPS}),
-                       used only if C{B{exact} is None}.
+                         see method L{geodesic_<pygeodesy.Ellipsoid.geodesic_>}.
+           @kwarg eps: Optional tolerance (C{EPS}), used only if C{B{exact} is None},
+                       see function L{intersection3d3<pygeodesy.intersection3d3>}.
            @kwarg est: Optionally, an initial estimate for the distance C{s12} of the
                        intersection I{along} this rhumb line (C{meter}), used only if
                        C{B{exact} is not None}.
@@ -849,11 +849,11 @@ class RhumbLineBase(_CapsBase):
                                <https://PyPI.org/project/geographiclib>}
                                package not found or not installed.
 
-           @raise IntersectionError: No convergence for this B{C{eps}} or no
-                                     intersection for some other reason.
+           @raise IntersectionError: No convergence for this B{C{eps}} or B{C{tol}} or
+                                     no intersection for some other reason.
 
-           @see: Methods C{distance2}, C{Intersecant2} and C{Intersection}
-                 and function L{pygeodesy.intersection3d3}.
+           @see: Methods C{distance2}, C{Intersecant2} and C{Intersection} and function
+                 L{intersection3d3<pygeodesy.intersection3d3>}.
         '''
         Cs, tol = Caps, Float_(tol=tol, low=EPS, high=None)
 
@@ -899,7 +899,7 @@ class RhumbLineBase(_CapsBase):
                        lat0=lat0, lon0=lon0, iteration=i, at=r.azi2 - self.azi12,
                        name=_dunder_nameof(self.PlumbTo, self.name))
             except Exception as x:  # Fsum(NAN) Value-, ZeroDivisionError
-                raise IntersectionError(lat0, lon0, tol=tol, exact=exact,
+                raise IntersectionError(lat0=lat0, lon0=lon0, tol=tol, exact=exact,
                                         eps=eps, est=est, iteration=i, cause=x)
 
         return P
@@ -907,29 +907,28 @@ class RhumbLineBase(_CapsBase):
     def Position(self, s12, outmask=Caps.LATITUDE_LONGITUDE):
         '''Compute a point at a given distance on this rhumb line.
 
-           @arg s12: The distance along this rhumb line from its origin to
-                     the point (C{meters}), can be negative.
-           @kwarg outmask: Bit-or'ed combination of L{Caps} values specifying
-                           the quantities to be returned.
+           @arg s12: The distance along this rhumb line from its origin to the point
+                     (C{meters}), can be negative.
+           @kwarg outmask: Bit-or'ed combination of L{Caps} values specifying the
+                           quantities to be returned.
 
-           @return: L{GDict} with 4 to 8 items C{azi12, a12, s12, S12, lat2,
-                    lat1, lon2, lon1} with latitude C{lat2} and longitude
-                    C{lon2} of the point in C{degrees}, the rhumb angle C{a12}
-                    in C{degrees} from the start point of and the area C{S12}
-                    under this rhumb line in C{meter} I{squared}.
+           @return: L{GDict} with 4 to 8 items C{azi12, a12, s12, S12, lat2, lat1,
+                    lon2, lon1} with latitude C{lat2} and longitude C{lon2} of the
+                    point in C{degrees}, the rhumb angle C{a12} in C{degrees} from
+                    the start point of and the area C{S12} under this rhumb line
+                    in C{meter} I{squared}.
 
-           @raise ImportError: Package C{numpy} not found or not installed,
-                               only required for L{RhumbLineAux} area C{S12}
-                               when C{B{exact} is True}.
+           @raise ImportError: Package C{numpy} not found or not installed, required
+                               only for L{RhumbLineAux} area C{S12} when C{B{exact}
+                               is True}.
 
-           @note: If B{C{s12}} is large enough that the rhumb line crosses a
-                  pole, the longitude of the second point is indeterminate and
-                  C{NAN} is returned for C{lon2} and area C{S12}.
+           @note: If B{C{s12}} is large enough that the rhumb line crosses a pole, the
+                  longitude of the second point is indeterminate and C{NAN} is returned
+                  for C{lon2} and area C{S12}.
 
-                  If the first point is a pole, the cosine of its latitude is
-                  taken to be C{sqrt(L{EPS})}.  This position is extremely
-                  close to the actual pole and allows the calculation to be
-                  carried out in finite terms.
+                  If the first point is a pole, the cosine of its latitude is taken to
+                  be C{sqrt(L{EPS})}.  This position is extremely close to the actual
+                  pole and allows the calculation to be carried out in finite terms.
         '''
         return self._Position(self.m2degrees(s12), s12, outmask)
 

pygeodesy/rhumb/ekx.py

@@ -43,7 +43,7 @@ from pygeodesy.utily import atan1, sincos2_
 from math import asinh, atan, cos, cosh, radians, sin, sinh, sqrt, tan
 
 __all__ = _ALL_LAZY.rhumb_ekx
-__version__ = '24.05.30'
+__version__ = '24.06.11'
 
 
 class Rhumb(RhumbBase):
@@ -61,13 +61,12 @@ class Rhumb(RhumbBase):
            @kwarg a_earth: This rhumb's earth model (L{Datum}, L{Ellipsoid},
                            L{Ellipsoid2}, L{a_f2Tuple}, 2-tuple C{(a, f)}) or
                            the (equatorial) radius (C{meter}, conventionally).
-           @kwarg f: The ellipsoid's flattening (C{scalar}), iff B{C{a_earth}} is
-                     C{scalar}, ignored otherwise.
+           @kwarg f: The ellipsoid's flattening (C{scalar}), required if B{C{a_earth}}
+                     is C{scalar}, ignored otherwise.
            @kwarg exact: If C{True}, use an addition theorem for elliptic integrals
                          to compute I{Divided differences}, otherwise use the I{Krüger}
                          series expansion (C{bool} or C{None}), see also properties
                          C{exact} and C{TMorder}.
-           @kwarg name: Optional name (C{str}).
            @kwarg RA_TMorder_name: Optional C{B{name}=NN} (C{str}) and optional keyword
                      arguments B{C{RAorder}=6} and B{C{TMorder}=6} to set the respective
                      C{order}, see properties C{RAorder} and C{TMorder}.

pygeodesy/rhumb/solve.py

@@ -17,21 +17,21 @@ from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv,
                              _PYGEODESY_RHUMBSOLVE_
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
 from pygeodesy.props import deprecated_method, Property, Property_RO
-from pygeodesy.solveBase import _SolveBase, _SolveLineBase
+from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.rhumb_solve
-__version__ = '24.06.04'
+__version__ = '24.06.28'
 
 
-class _RhumbSolveBase(_SolveBase):
+class _RhumbSolveBase(_SolveGDictBase):
     '''(INTERNAL) Base class for L{RhumbSolve} and L{RhumbLineSolve}.
     '''
     _Error         =  RhumbError
     _Names_Direct  = _lat2_, _lon2_, _S12_
     _Names_Inverse = _azi12_, _s12_, _S12_
-    _Solve_name    = 'RhumbSolve'
-    _Solve_path    = _getenv(_PYGEODESY_RHUMBSOLVE_, _PYGEODESY_RHUMBSOLVE_)
+    _Xable_name    = 'RhumbSolve'
+    _Xable_path    = _getenv(_PYGEODESY_RHUMBSOLVE_, _PYGEODESY_RHUMBSOLVE_)
 
     @Property_RO
     def _cmdBasic(self):
@@ -46,7 +46,7 @@ class _RhumbSolveBase(_SolveBase):
         '''Get the U{RhumbSolve<https://GeographicLib.SourceForge.io/C++/doc/RhumbSolve.1.html>}
            executable (C{filename}).
         '''
-        return self._Solve_path
+        return self._Xable_path
 
     @RhumbSolve.setter  # PYCHOK setter!
     def RhumbSolve(self, path):
@@ -56,7 +56,7 @@ class _RhumbSolveBase(_SolveBase):
            @raise RhumbError: Invalid B{C{path}}, B{C{path}} doesn't exist or isn't
                               the C{RhumbSolve} executable.
         '''
-        self._setSolve(path)
+        self._setXable(path)
 
     @Property_RO
     def _s_option(self):  # == not -E for GeodSolve
@@ -65,11 +65,11 @@ class _RhumbSolveBase(_SolveBase):
     def toStr(self, **prec_sep):  # PYCHOK signature
         '''Return this C{RhumbSolve} as string.
 
-           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=', '}
+           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=", "}
                       for the C{float} C{prec}ision, number of decimal digits
                       (0..9) and the C{sep}arator string to join.  Trailing
-                      zero decimals are stripped for B{C{prec}} values of
-                      1 and above, but kept for negative B{C{prec}} values.
+                      zero decimals are stripped for B{C{prec}} values of 1
+                      and above, but kept for negative B{C{prec}} values.
 
            @return: RhumbSolve items (C{str}).
         '''
@@ -173,8 +173,7 @@ class RhumbSolve(_RhumbSolveBase):
         return r
 
     def _GDictInverse(self, lat1, lon1, lat2, lon2, *unused, **floats):  # PYCHOK signature
-        '''(INTERNAL) Get C{_GenInverse}-like result as an 8-item C{GDict}, but
-           I{without} C{_SALPs_CALPs_}.
+        '''(INTERNAL) Get C{_GenInverse}-like result as an 8-item C{GDict}, but I{without} C{_S_CALPs_}.
         '''
         i = _RhumbSolveBase._GDictInverse(self, lat1, lon1, lat2, lon2, **floats)
         a = _over(float(i.s12), self._mpd)  # for .Inverse1
@@ -231,7 +230,7 @@ class RhumbSolve(_RhumbSolveBase):
     Line = DirectLine
 
 
-class RhumbLineSolve(_RhumbSolveBase, _SolveLineBase):
+class RhumbLineSolve(_RhumbSolveBase, _SolveGDictLineBase):
     '''Wrapper to invoke I{Karney}'s U{RhumbSolve<https://GeographicLib.SourceForge.io/C++/doc/RhumbSolve.1.html>}
        like a class, similar to L{pygeodesy.RhumbLine} and L{pygeodesy.RhumbLineAux}.
 
@@ -267,7 +266,7 @@ class RhumbLineSolve(_RhumbSolveBase, _SolveLineBase):
         _xinstanceof(RhumbSolve, rhumb=rhumb)
         if (caps & Caps.LINE_OFF):  # copy to avoid updates
             rhumb = rhumb.copy(deep=False, name=NN(_UNDER_, rhumb.name))
-        _SolveLineBase.__init__(self, rhumb, lat1, lon1, caps, azi12=azi12, **name)
+        _SolveGDictLineBase.__init__(self, rhumb, lat1, lon1, caps, azi12=azi12, **name)
         try:
             self.RhumbSolve = rhumb.RhumbSolve  # rhumb or copy of rhumb
         except RhumbError:
@@ -283,7 +282,7 @@ class RhumbLineSolve(_RhumbSolveBase, _SolveLineBase):
 #                   azi12, a12, s12, S12}.
 #       '''
 #       s = a12 * self._mpd
-#       a = self._GDictInvoke(self._cmdArc, True, self._Names_Direct, s)
+#       a = self._GDictInvoke(self._cmdArc, self._Names_Direct, s)
 #       r = GDict(a12=a12, s12=s, **self._lla1)
 #       r.updated(a)
 #       return r
@@ -318,7 +317,7 @@ class RhumbLineSolve(_RhumbSolveBase, _SolveLineBase):
            @return: A L{GDict} with 7 items C{lat1, lon1, lat2, lon2,
                     azi12, s12, S12}.
         '''
-        d = self._GDictInvoke(self._cmdDistance, True, self._Names_Direct, s12)
+        d = self._GDictInvoke(self._cmdDistance, self._Names_Direct, s12)
         r = GDict(s12=s12, **self._lla1)  # a12=_over(s12, self._mpd)
         r.update(d)
         return r
@@ -326,16 +325,16 @@ class RhumbLineSolve(_RhumbSolveBase, _SolveLineBase):
     def toStr(self, **prec_sep):  # PYCHOK signature
         '''Return this C{RhumbLineSolve} as string.
 
-           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=', '}
+           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=", "}
                       for the C{float} C{prec}ision, number of decimal digits
                       (0..9) and the C{sep}arator string to join.  Trailing
-                      zero decimals are stripped for B{C{prec}} values of
-                      1 and above, but kept for negative B{C{prec}} values.
+                      zero decimals are stripped for B{C{prec}} values of 1
+                      and above, but kept for negative B{C{prec}} values.
 
            @return: RhumbLineSolve items (C{str}).
         '''
-        return _SolveLineBase._toStr(self, azi12=self.azi12, rhumb=self._solve,
-                                           RhumbSolve=self.RhumbSolve, **prec_sep)
+        return _SolveGDictLineBase._toStr(self, azi12=self.azi12, rhumb=self._solve,
+                                                RhumbSolve=self.RhumbSolve, **prec_sep)
 
 
 class RhumbSolve7Tuple(Rhumb8Tuple):
@@ -396,7 +395,7 @@ if __name__ == '__main__':
     rS.verbose = '--verbose' in argv  # or '-v' in argv
 
     if rS.RhumbSolve in (_PYGEODESY_RHUMBSOLVE_, None):  # not set
-        rS.RhumbSolve = '/opt/local/bin/RhumbSolve'  # '/opt/local/Cellar/geographiclib/2.2/bin/RhumbSolve'  # HomeBrew
+        rS.RhumbSolve = '/opt/local/bin/RhumbSolve'  # '/opt/local/Cellar/geographiclib/2.3/bin/RhumbSolve'  # HomeBrew
     printf('version: %s', rS.version)
 
     if len(argv) > 6:  # 60 0 30 0 45 1e6