pygeodesy 24.6.1__py2.py3-none-any.whl → 24.6.24__py2.py3-none-any.whl

pygeodesy/osgr.py

@@ -46,14 +46,14 @@ from pygeodesy.namedTuples import EasNor2Tuple, LatLon2Tuple, \
 from pygeodesy.props import Property_RO, property_RO
 from pygeodesy.streprs import _EN_WIDE, enstr2, _enstr2m3, Fmt, \
                               _resolution10, unstr, _xzipairs
-from pygeodesy.units import Easting, Lam_, Lat, Lon, Northing, \
-                            Phi_, Scalar, _10um, _100km
+from pygeodesy.units import Easting, Lamd, Lat, Lon, Northing, \
+                            Phid, Scalar, _10um, _100km
 from pygeodesy.utily import degrees90, degrees180, sincostan3, truncate
 
 from math import cos, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.osgr
-__version__ = '24.05.31'
+__version__ = '24.06.15'
 
 _equivalent_ = 'equivalent'
 _OSGR_       = 'OSGR'
@@ -108,7 +108,7 @@ class _NG(object):
 
     @Property_RO
     def lam0(self):  # True origin longitude C{radians}
-        return Lam_(self.lon0)
+        return Lamd(self.lon0)
 
     @Property_RO
     def lat0(self):  # True origin latitude, 49°N
@@ -160,7 +160,7 @@ class _NG(object):
 
     @Property_RO
     def phi0(self):  # True origin latitude C{radians}
-        return Phi_(self.lat0)
+        return Phid(self.lat0)
 
     def reverse(self, osgr):  # convert C{osgr} to (ellipsoidal} LatLon, as I{Karney}'s
         # U{Reverse<https://GeographicLib.SourceForge.io/C++/doc/OSGB_8hpp_source.html>}
@@ -296,7 +296,7 @@ class Osgr(_NamedBase):
            @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
                                arguments, ignored if C{B{LatLon} is None}.
 
-           @return: A B{C{LatLon}} instance or if B{C{LatLon}} is C{None}
+           @return: A B{C{LatLon}} instance or if C{B{LatLon} is None}
                     a L{LatLonDatum3Tuple}C{(lat, lon, datum)}.
 
            @note: While OS grid references are based on the OSGB36 datum,
@@ -520,8 +520,8 @@ def parseOSGR(strOSGR, Osgr=Osgr, **name_Osgr_kwds):
                    optional, additional B{C{Osgr}} keyword arguments,
                    ignored if C{B{Osgr} is None}.
 
-       @return: An (B{C{Osgr}}) instance or if B{C{Osgr}} is
-                C{None} an L{EasNor2Tuple}C{(easting, northing)}.
+       @return: An (B{C{Osgr}}) instance or if C{B{Osgr} is None}, an
+                L{EasNor2Tuple}C{(easting, northing)}.
 
        @raise OSGRError: Invalid B{C{strOSGR}}.
     '''
@@ -598,7 +598,7 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr,  # MCCABE 14
                    and additional B{C{Osgr}} keyword arguments,
                    ignored if C{B{Osgr} is None}.
 
-       @return: An (B{C{Osgr}}) instance or if B{C{Osgr}} is C{None}
+       @return: An (B{C{Osgr}}) instance or if C{B{Osgr} is None}
                 an L{EasNor2Tuple}C{(easting, northing)}.
 
        @note: If L{isint}C{(B{prec})} both easting and northing are

pygeodesy/points.py

@@ -62,7 +62,7 @@ from pygeodesy.utily import atan2b, degrees90, degrees180, degrees2m, \
 from math import cos, fabs, fmod as _fmod, radians, sin
 
 __all__ = _ALL_LAZY.points
-__version__ = '24.05.25'
+__version__ = '24.06.15'
 
 _ilat_  = 'ilat'
 _ilon_  = 'ilon'
@@ -391,7 +391,7 @@ class _Array2LatLon(_Basequence):  # immutable, on purpose
         # check the attr indices
         for n, (ai, i) in enumerate(ais):
             if not isint(i):
-                raise _IsnotError(int.__name__, **{ai: i})
+                raise _IsnotError(int, **{ai: i})
             i = int(i)
             if not 0 <= i < shape[1]:
                 raise _ValueError(ai, i)
@@ -959,8 +959,8 @@ def areaOf(points, adjust=True, radius=R_M, wrap=True):
                     the B{C{points}} (C{bool}).
 
        @return: Approximate area (I{square} C{meter}, same units as
-                B{C{radius}} or C{radians} I{squared} if B{C{radius}}
-                is C{None}).
+                B{C{radius}} or C{radians} I{squared} if C{B{radius}
+                is None}).
 
        @raise PointsError: Insufficient number of B{C{points}}
 
@@ -992,8 +992,8 @@ def boundsOf(points, wrap=False, LatLon=None):  # was=True
        @kwarg LatLon: Optional class to return the C{bounds}
                       corners (C{LatLon}) or C{None}.
 
-       @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)} as
-                B{C{LatLon}}s if B{C{LatLon}} is C{None} a
+       @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)}, each
+                a B{C{LatLon}} or if C{B{LatLon} is None}, a
                 L{Bounds4Tuple}C{(latS, lonW, latN, lonE)}.
 
        @raise PointsError: Insufficient number of B{C{points}}
@@ -1479,7 +1479,7 @@ def nearestOn5(point, points, closed=False, wrap=False, adjust=True,
                      spherical earth radius L{R_KM}).
        @kwarg LatLon_and_kwds: Optional, C{B{LatLon}=None} class to use for
                      the closest point and additional B{C{LatLon}} keyword
-                     arguments, ignored if C{B{LatLon}=None} or not given.
+                     arguments, ignored if C{B{LatLon} is None} or not given.
 
        @return: A L{NearestOn3Tuple}C{(closest, distance, angle)} with the
                 {closest} point (B{C{LatLon}}) or if C{B{LatLon} is None},

pygeodesy/rhumb/__init__.py

@@ -9,7 +9,7 @@ u'''Package of lazily imported C{rhumb} modules L{rhumb.aux_}, L{rhumb.ekx} and
 from pygeodesy.lazily import _ALL_LAZY, _ALL_OTHER, _lazy_import_as, _unLazy0
 
 __all__ = _ALL_LAZY.rhumb
-__version__ = '24.05.24'
+__version__ = '24.06.18'
 
 if _unLazy0:  # or _isfrozen
     from pygeodesy.rhumb.aux_ import RhumbAux, RhumbLineAux

pygeodesy/rhumb/aux_.py

@@ -47,7 +47,7 @@ from pygeodesy.rhumb.bases import RhumbBase, RhumbLineBase, \
 from math import ceil as _ceil, fabs, radians
 
 __all__ = _ALL_LAZY.rhumb_aux_
-__version__ = '24.05.29'
+__version__ = '24.06.11'
 
 # DIGITS = (sizeof(real) * 8) bits
 #        = (ctypes.sizeof(ctypes.c_double(1.0)) * 8) bits
@@ -74,14 +74,14 @@ class RhumbAux(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 the exact expressions for the I{Auxiliary
                          Latitudes}, otherwise use the I{Fourier} series expansion
                          (C{bool}), see also property C{exact}.
            @kwarg TMorder_name: Optional C{B{name}=NN} (C{str}) and optional
-                          keyword argument C{B{TMorder}=6} for the order of
-                          the L{KTransverseMercator}, see property C{TMorder}.
+                          keyword argument C{B{TMorder}=6}, the order of the
+                          L{KTransverseMercator}, see property C{TMorder}.
 
            @raise ImportError: Package C{numpy} not found or not installed, only
                                required for area C{S12} when C{B{exact} is True}.

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

@@ -21,7 +21,7 @@ from pygeodesy.solveBase import _SolveBase, _SolveLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.rhumb_solve
-__version__ = '24.05.31'
+__version__ = '24.06.04'
 
 
 class _RhumbSolveBase(_SolveBase):
@@ -37,9 +37,9 @@ class _RhumbSolveBase(_SolveBase):
     def _cmdBasic(self):
         '''(INTERNAL) Get the basic C{RhumbSolve} cmd (C{tuple}).
         '''
-        return (self.RhumbSolve,) + self._e_option \
-                                  + self._p_option \
-                                  + self._s_option
+        return (self.RhumbSolve,) + (self._e_option +
+                                     self._p_option +
+                                     self._s_option)
 
     @Property
     def RhumbSolve(self):
@@ -423,59 +423,6 @@ if __name__ == '__main__':
 #   p = rlS.ArcPosition(49.475527)
 #   printf('ArcPosition: %s %r', p == r, p)
 
-# % python3 -m pygeodesy.rhumb.solve
-
-# version: /opt/local/bin/RhumbSolve: GeographicLib version 1.51
-#
-# Direct: GDict(S12=44095641862956.148438, azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0)
-# Direct3: Destination3Tuple(lat=71.6889, lon=0.25552, final=51.0)
-#
-# Inverse: GDict(S12=37395209100030.367188, a12=51.929543, azi12=77.76839, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, s12=5771083.383328)
-# Inverse1: 51.92954250756195
-# Inverse3: Distance3Tuple(distance=5771083.383328, initial=77.76839, final=77.76839)
-#
-# Inverse: GDict(S12=-63760642939072.492188, a12=115.02062, azi12=-92.388888, lat1=40.6, lat2=35.8, lon1=-73.8, lon2=140.3, s12=12782581.067684)
-# Inverse1: 115.02061966879258
-# Inverse3: Distance3Tuple(distance=12782581.067684, initial=267.611112, final=267.611112)
-#
-# Position:    True  GDict(S12=44095641862956.148438, azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0)
-
-
-# % python3 -m pygeodesy.rhumb.solve --verbose
-
-# RhumbSolve 'Test' 1: /opt/local/bin/RhumbSolve --version (invoke)
-# RhumbSolve 'Test' 1: /opt/local/bin/RhumbSolve: GeographicLib version 1.51 (0)
-# version: /opt/local/bin/RhumbSolve: GeographicLib version 1.51
-# RhumbSolve 'Test' 2: /opt/local/bin/RhumbSolve -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct)
-# RhumbSolve 'Test' 2: lat2=71.688899882813047, lon2=0.255519824423445, S12=44095641862956.148 (0)
-
-# Direct: GDict(S12=44095641862956.148438, azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0)
-# RhumbSolve 'Test' 3: /opt/local/bin/RhumbSolve -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct3)
-# RhumbSolve 'Test' 3: lat2=71.688899882813047, lon2=0.255519824423445, S12=44095641862956.148 (0)
-# Direct3: Destination3Tuple(lat=71.6889, lon=0.25552, final=51.0)
-# RhumbSolve 'Test' 4: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse)
-# RhumbSolve 'Test' 4: azi12=77.768389710255661, s12=5771083.3833280317, S12=37395209100030.367 (0)
-
-# Inverse: GDict(S12=37395209100030.367188, a12=51.929543, azi12=77.76839, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, s12=5771083.383328)
-# RhumbSolve 'Test' 5: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
-# RhumbSolve 'Test' 5: azi12=77.768389710255661, s12=5771083.3833280317, S12=37395209100030.367 (0)
-# Inverse1: 51.92954250756195
-# RhumbSolve 'Test' 6: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
-# RhumbSolve 'Test' 6: azi12=77.768389710255661, s12=5771083.3833280317, S12=37395209100030.367 (0)
-# Inverse3: Distance3Tuple(distance=5771083.383328, initial=77.76839, final=77.76839)
-# RhumbSolve 'Test' 7: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse)
-# RhumbSolve 'Test' 7: azi12=-92.388887981699639, s12=12782581.0676841792, S12=-63760642939072.492 (0)
-
-# Inverse: GDict(S12=-63760642939072.492188, a12=115.02062, azi12=-92.388888, lat1=40.6, lat2=35.8, lon1=-73.8, lon2=140.3, s12=12782581.067684)
-# RhumbSolve 'Test' 8: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse1)
-# RhumbSolve 'Test' 8: azi12=-92.388887981699639, s12=12782581.0676841792, S12=-63760642939072.492 (0)
-# Inverse1: 115.02061966879258
-# RhumbSolve 'Test' 9: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse3)
-# RhumbSolve 'Test' 9: azi12=-92.388887981699639, s12=12782581.0676841792, S12=-63760642939072.492 (0)
-# Inverse3: Distance3Tuple(distance=12782581.067684, initial=267.611112, final=267.611112)
-
-# Position:    True  GDict(S12=44095641862956.148438, azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0)
-
 
 # % python3 -m pygeodesy.rhumb.solve
 
@@ -485,11 +432,11 @@ if __name__ == '__main__':
 # Direct3: Destination3Tuple(lat=71.6889, lon=0.25552, final=51.0)
 
 # Inverse: GDict(a12=51.929543, azi12=77.76839, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, s12=5771083.383328, S12=37395209100030.390625)
-# Inverse1: 51.92954250756191
+# Inverse1: 51.929542507561905
 # Inverse3: Distance3Tuple(distance=5771083.383328, initial=77.76839, final=77.76839)
 
 # Inverse: GDict(a12=115.02062, azi12=-92.388888, lat1=40.6, lat2=35.8, lon1=-73.8, lon2=140.3, s12=12782581.067684, S12=-63760642939072.5)
-# Inverse1: 115.02061966879249
+# Inverse1: 115.02061966879248
 # Inverse3: Distance3Tuple(distance=12782581.067684, initial=267.611112, final=267.611112)
 
 # Position:    True  GDict(azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0, S12=44095641862956.109375)
@@ -513,7 +460,7 @@ if __name__ == '__main__':
 # Inverse: GDict(a12=51.929543, azi12=77.76839, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, s12=5771083.383328, S12=37395209100030.390625)
 # RhumbSolve 'Test' 5: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
 # RhumbSolve 'Test' 5: azi12=77.768389710255661, s12=5771083.383328028, S12=37395209100030.391 (0)
-# Inverse1: 51.92954250756191
+# Inverse1: 51.929542507561905
 # RhumbSolve 'Test' 6: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
 # RhumbSolve 'Test' 6: azi12=77.768389710255661, s12=5771083.383328028, S12=37395209100030.391 (0)
 # Inverse3: Distance3Tuple(distance=5771083.383328, initial=77.76839, final=77.76839)
@@ -523,7 +470,7 @@ if __name__ == '__main__':
 # Inverse: GDict(a12=115.02062, azi12=-92.388888, lat1=40.6, lat2=35.8, lon1=-73.8, lon2=140.3, s12=12782581.067684, S12=-63760642939072.5)
 # RhumbSolve 'Test' 8: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse1)
 # RhumbSolve 'Test' 8: azi12=-92.388887981699654, s12=12782581.0676841699, S12=-63760642939072.5 (0)
-# Inverse1: 115.02061966879249
+# Inverse1: 115.02061966879248
 # RhumbSolve 'Test' 9: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse3)
 # RhumbSolve 'Test' 9: azi12=-92.388887981699654, s12=12782581.0676841699, S12=-63760642939072.5 (0)
 # Inverse3: Distance3Tuple(distance=12782581.067684, initial=267.611112, final=267.611112)

pygeodesy/solveBase.py

@@ -13,7 +13,7 @@ from pygeodesy.internals import _enquote, printf
 from pygeodesy.interns import NN, _0_, _BACKSLASH_, _COMMASPACE_, \
                              _EQUAL_, _Error_, _SPACE_, _UNUSED_
 from pygeodesy.karney import Caps, _CapsBase, GDict
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _unlazy
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _sys_version_info2
 from pygeodesy.named import callername, _name2__, notOverloaded
 from pygeodesy.props import Property, Property_RO, property_RO, _update_all
 from pygeodesy.streprs import Fmt, fstr, fstrzs, pairs, strs
@@ -23,34 +23,37 @@ from pygeodesy.utily import unroll180,  wrap360  # PYCHOK shared
 from subprocess import PIPE as _PIPE, Popen as _Popen, STDOUT as _STDOUT
 
 __all__ = _ALL_LAZY.solveBase
-__version__ = '24.05.31'
+__version__ = '24.06.05'
 
-_ERROR_    = 'ERROR'
-_text_True =  dict() if _unlazy else dict(text=True)
+_ERROR_     = 'ERROR'
+_Popen_kwds =  dict(creationflags=0,
+                  # executable=sys.executable, shell=True,
+                    stdin=_PIPE, stdout=_PIPE, stderr=_STDOUT)
+if _sys_version_info2 > (3, 6):
+    _Popen_kwds.update(text=True)
+del _PIPE, _STDOUT, _sys_version_info2  # _ALL_LAZY
 
 
 def _cmd_stdin_(cmd, stdin):  # PYCHOK no cover
     '''(INTERNAL) Cmd line, stdin and caller as sC{str}.
     '''
-    c = Fmt.PAREN(callername(up=3))
-    t = (c,) if stdin is None else (_BACKSLASH_, str(stdin), c)
-    return _SPACE_.join(cmd + t)
+    if stdin is not None:
+        cmd += _BACKSLASH_, str(stdin)
+    cmd += Fmt.PAREN(callername(up=3)),
+    return _SPACE_.join(cmd)
 
 
-def _popen2(cmd, stdin=None):  # in .mgrs, .test.base, .test.testMgrs
+def _popen2(cmd, stdin=None):  # in .mgrs, test.bases, .testMgrs
     '''(INTERNAL) Invoke C{B{cmd} tuple} and return C{exitcode}
        and all output to C{stdout/-err}.
     '''
-    p = _Popen(cmd, creationflags=0,
-                  # executable=sys.executable, shell=True,
-                    stdin=_PIPE, stdout=_PIPE, stderr=_STDOUT,
-                 **_text_True)  # PYCHOK kwArgs
-    r = p.communicate(stdin)[0]
+    p = _Popen(cmd, **_Popen_kwds)  # PYCHOK kwArgs
+    r =  p.communicate(stdin)[0]
     return p.returncode, ub2str(r).strip()
 
 
-class _SolveLineSolveBase(_CapsBase):
-    '''(NTERNAL) Base class for C{_Solve} and C{_LineSolve}.
+class _SolveCapsBase(_CapsBase):
+    '''(NTERNAL) Base class for C{_SolveBase} and C{_LineSolveBase}.
     '''
     _Error         =  None
     _Exact         =  True
@@ -131,7 +134,7 @@ class _SolveLineSolveBase(_CapsBase):
 
            @note: The C{Solve} return code is in property L{status}.
         '''
-        c = (self._Solve_path,) + map2(str, options)
+        c = (self._Solve_path,) + map2(str, options)  # map2(_enquote, options)
         i = _xkwds_get1(stdin, stdin=None)
         r =  self._invoke(c, stdin=i)
         s =  self.status
@@ -270,7 +273,7 @@ class _SolveLineSolveBase(_CapsBase):
         return self.invoke('--version')
 
 
-class _SolveBase(_SolveLineSolveBase):
+class _SolveBase(_SolveCapsBase):
     '''(NTERNAL) Base class for C{_GeodesicSolveBase} and C{_RhumbSolveBase}.
     '''
     _datum = _WGS84
@@ -387,7 +390,7 @@ class _SolveBase(_SolveLineSolveBase):
         return sep.join(pairs(d, prec=prec))
 
 
-class _SolveLineBase(_SolveLineSolveBase):
+class _SolveLineBase(_SolveCapsBase):
     '''(NTERNAL) Base class for C{GeodesicLineSolve} and C{RhumbLineSolve}.
     '''
 #   _caps  =  0
@@ -448,7 +451,7 @@ class _SolveLineBase(_SolveLineSolveBase):
         return sep.join(pairs(d, prec=prec))
 
 
-__all__ += _ALL_DOCS(_SolveBase, _SolveLineBase, _SolveLineSolveBase)
+__all__ += _ALL_DOCS(_SolveBase, _SolveLineBase, _SolveCapsBase)
 
 # **) MIT License
 #

pygeodesy/sphericalBase.py

@@ -19,7 +19,7 @@ from pygeodesy.constants import EPS, EPS0, PI, PI2, PI_2, R_M, \
                                _over, isnear0, isnon0
 from pygeodesy.datums import Datums, _earth_ellipsoid, _spherical_datum
 from pygeodesy.errors import IntersectionError, _ValueError, \
-                            _xattr, _xError
+                            _xattr, _xattrs, _xError
 from pygeodesy.fmath import favg, fdot, hypot, sqrt_a
 from pygeodesy.interns import _COMMA_, _concentric_, _datum_, _distant_, \
                               _exceed_PI_radians_, _name_, _near_, \
@@ -27,10 +27,10 @@ from pygeodesy.interns import _COMMA_, _concentric_, _datum_, _distant_, \
 from pygeodesy.latlonBase import LatLonBase,  _trilaterate5  # PYCHOK passed
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.namedTuples import Bearing2Tuple  # from .cartesianBase
-from pygeodesy.nvectorBase import NvectorBase,  Fmt, _xattrs
+from pygeodesy.nvectorBase import NvectorBase,  Fmt
 from pygeodesy.props import deprecated_method, property_doc_, property_RO, \
                            _update_all
-# from pygeodesy.streprs import Fmt, _xattrs  # from .nvectorBase
+# from pygeodesy.streprs import Fmt  # from .nvectorBase
 from pygeodesy.units import Bearing, Bearing_, _isRadius, Radians_, Radius, \
                             Radius_, Scalar_, _100km
 from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
@@ -40,7 +40,7 @@ from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
 from math import cos, fabs, log, sin, sqrt
 
 __all__ = _ALL_LAZY.sphericalBase
-__version__ = '24.05.31'
+__version__ = '24.06.12'
 
 
 class CartesianSphericalBase(CartesianBase):
@@ -380,7 +380,8 @@ class LatLonSphericalBase(LatLonBase):
         '''DEPRECATED, use method C{.rhumbAzimuthTo}.'''
         return self.rhumbAzimuthTo(other, b360=True)  # [0..360)
 
-    def rhumbDestination(self, distance, azimuth, radius=R_M, height=None, exact=False):
+    def rhumbDestination(self, distance, azimuth, radius=R_M, height=None,
+                                                   exact=False, **name):
         '''Return the destination point having travelled the given distance from
            this point along a rhumb line (loxodrome) of the given azimuth.
 
@@ -393,6 +394,7 @@ class LatLonSphericalBase(LatLonBase):
            @kwarg height: Optional height, overriding the default height (C{meter}.
            @kwarg exact: If C{True}, use I{Elliptic, Krüger} L{Rhumb} (C{bool}),
                          default C{False} for backward compatibility.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: The destination point (spherical C{LatLon}).
 
@@ -401,7 +403,7 @@ class LatLonSphericalBase(LatLonBase):
         '''
         if exact:  # use series, always
             r = LatLonBase.rhumbDestination(self, distance, azimuth, exact=False,  # Krüger
-                                                  radius=radius, height=height)
+                                                  radius=radius, height=height, **name)
         else:  # radius=None from .rhumbMidpointTo
             if radius in (None, self._radius):
                 d, r = self.datum, radius
@@ -425,7 +427,7 @@ class LatLonSphericalBase(LatLonBase):
             b2 = b1 if isnear0(q) else (b1 + r * sb / q)
 
             h = self._heigHt(height)
-            r = self.classof(degrees90(a2), degrees180(b2), datum=d, height=h)
+            r = self.classof(degrees90(a2), degrees180(b2), datum=d, height=h, **name)
         return r
 
     def rhumbDistanceTo(self, other, radius=R_M, exact=False, wrap=False):
@@ -441,8 +443,8 @@ class LatLonSphericalBase(LatLonBase):
            @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
                         B{C{other}} point (C{bool}).
 
-           @return: Distance (C{meter}, the same units as B{C{radius}}
-                    or C{radians} if B{C{radius}} is C{None}).
+           @return: Distance (C{meter}, the same units as B{C{radius}} or
+                    C{radians} if C{B{radius} is None}).
 
            @raise TypeError: The B{C{other}} point is incompatible.
 
@@ -499,7 +501,7 @@ class LatLonSphericalBase(LatLonBase):
                                              height=height, wrap=wrap)
 
     def rhumbMidpointTo(self, other, height=None, radius=R_M, exact=False,
-                                                fraction=_0_5, wrap=False):
+                                                fraction=_0_5, **wrap_name):
         '''Return the (loxodromic) midpoint on the rhumb line between
            this and an other point.
 
@@ -511,8 +513,9 @@ class LatLonSphericalBase(LatLonBase):
                          default C{False} for backward compatibility.
            @kwarg fraction: Midpoint location from this point (C{scalar}), may
                             be negative if C{B{exact}=True}.
-           @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{other}}
-                        point (C{bool}).
+           @kwarg wrap_name: Optional C{B{name}=NN} (C{str}) and optional keyword
+                       argument C{B{wrap}=False}, if C{True}, wrap or I{normalize}
+                       and unroll the B{C{other}} point (C{bool}).
 
            @return: The (mid)point at the given B{C{fraction}} along the rhumb
                     line (spherical C{LatLon}).
@@ -524,18 +527,21 @@ class LatLonSphericalBase(LatLonBase):
         if exact:  # use series, always
             r = LatLonBase.rhumbMidpointTo(self, other, exact=False,  # Krüger
                                                  radius=radius, height=height,
-                                                 fraction=fraction, wrap=wrap)
+                                                 fraction=fraction, **wrap_name)
         elif fraction is not _0_5:
             f = Scalar_(fraction=fraction)  # low=_0_0
-            r, db, dp = self._rhumbs3(other, wrap, r=True)  # radians
+            w, n      = self._wrap_name2(**wrap_name)
+            r, db, dp = self._rhumbs3(other, w, r=True)  # radians
             z = atan2b(db, dp)
             h = self._havg(other, f=f, h=height)
-            r = self.rhumbDestination(r * f, z, radius=None, height=h)
+            r = self.rhumbDestination(r * f, z, radius=None, height=h, name=n)
 
         else:  # for backward compatibility, unwrapped
+            _,  n  = self._wrap_name2(**wrap_name)
             # see <https://MathForum.org/library/drmath/view/51822.html>
             a1, b1 = self.philam
             a2, b2 = self.others(other).philam
+            _,  n  = self._wrap_name2(**wrap_name)
 
             if fabs(b2 - b1) > PI:
                 b1 += PI2  # crossing anti-meridian
@@ -557,7 +563,7 @@ class LatLonSphericalBase(LatLonBase):
             d = self.datum if radius in (None, self._radius) else \
                _spherical_datum(radius, name=self.name, raiser=_radius_)
             h = self._havg(other, h=height)
-            r = self.classof(degrees90(a3), degrees180(b3), datum=d, height=h)
+            r = self.classof(degrees90(a3), degrees180(b3), datum=d, height=h, name=n)
         return r
 
     @property_RO
@@ -570,12 +576,11 @@ class LatLonSphericalBase(LatLonBase):
         '''Convert this point to C{Nvector} components, I{including
            height}.
 
-           @kwarg Nvector_kwds: Optional, additional B{C{Nvector}}
-                                keyword arguments, ignored if
-                                C{B{Nvector} is None}.
+           @kwarg Nvector_kwds: Optional, additional B{C{Nvector}} keyword
+                                arguments, ignored if C{B{Nvector} is None}.
 
-           @return: An B{C{Nvector}} or a L{Vector4Tuple}C{(x, y, z, h)}
-                    if B{C{Nvector}} is C{None}.
+           @return: An B{C{Nvector}} or a L{Vector4Tuple}C{(x, y, z, h)} if
+                    B{C{Nvector} is None}.
 
            @raise TypeError: Invalid B{C{Nvector}} or B{C{Nvector_kwds}}.
         '''