pygeodesy 25.8.25__py2.py3-none-any.whl → 25.10.10__py2.py3-none-any.whl

pygeodesy/geodesicx/gx.py

@@ -65,7 +65,7 @@ from pygeodesy.utily import atan2, atan2d as _atan2d_reverse, _unrollon, \
 from math import copysign, cos, degrees, fabs, radians, sqrt
 
 __all__ = ()
-__version__ = '25.06.01'
+__version__ = '25.09.16'
 
 _MAXIT1 = 20
 _MAXIT2 = 10 + _MAXIT1 + MANT_DIG  # MANT_DIG == C++ digits
@@ -134,7 +134,7 @@ class GeodesicExact(_GeodesicBase):
     _datum = _WGS84
     _nC4   =  30  # default C4order
 
-    def __init__(self, a_ellipsoid=_EWGS84, f=None, C4order=None, **name_C4Order):  # for backward compatibility
+    def __init__(self, a_ellipsoid=_EWGS84, f=None, caps=None, C4order=None, **name_C4Order):  # for backward compatibility
         '''New L{GeodesicExact} instance.
 
            @arg a_ellipsoid: An ellipsoid (L{Ellipsoid}) or datum (L{Datum}) or
@@ -142,6 +142,8 @@ class GeodesicExact(_GeodesicBase):
                              conventionally in C{meter}), see B{C{f}}.
            @arg f: The flattening of the ellipsoid (C{scalar}) if B{C{a_ellipsoid}}
                    is specified as C{scalar}.
+           @kwarg caps: Optional default capabilities for L{GeodesicLineExact} instances,
+                        use C{B{caps}=Caps.NONFINITONAN} to handle nonfinites silently.
            @kwarg C4order: Optional series expansion order (C{int}), see property
                            L{C4order}, default C{30}.
            @kwarg name_C4Order: Optional C{B{name}=NN} (C{str}) and the DEPRECATED
@@ -154,9 +156,11 @@ class GeodesicExact(_GeodesicBase):
             if name:
                 self.name = name
         else:
-            name = {}  # name_C4Order
+            name = name_C4Order  # no name
 
         _earth_datum(self, a_ellipsoid, f=f, **name)
+        if caps:
+            self._caps |= caps & Caps._OUT_MASK
         if C4order:  # XXX private copy, always?
             self.C4order = C4order
 
@@ -184,7 +188,7 @@ class GeodesicExact(_GeodesicBase):
                  <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicExact.html>}
                  and Python U{Geodesic.ArcDirect<https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
         '''
-        return self._GDictDirect(lat1, lon1, azi1, True, a12, outmask)
+        return self._GDictDirect(lat1, lon1, azi1, True, a12, outmask=outmask)
 
     def ArcDirectLine(self, lat1, lon1, azi1, a12, caps=Caps.ALL, **name):
         '''Define a L{GeodesicLineExact} in terms of the I{direct} geodesic problem and as arc length.
@@ -193,10 +197,7 @@ class GeodesicExact(_GeodesicBase):
            @arg lon1: Longitude of the first point (C{degrees}).
            @arg azi1: Azimuth at the first point (compass C{degrees}).
            @arg a12: Arc length between the points (C{degrees}), can be negative.
-           @kwarg caps: Bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>} values
-                        specifying the capabilities the L{GeodesicLineExact} instance
-                        should possess, i.e., which quantities can be returned by methods
-                        L{GeodesicLineExact.Position} and L{GeodesicLineExact.ArcPosition}.
+           @kwarg caps: Desired capabilities for the L{GeodesicLineExact} instance.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicLineExact} instance.
@@ -347,7 +348,7 @@ class GeodesicExact(_GeodesicBase):
                  <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicExact.html>}
                  and Python U{Geodesic.Direct<https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
         '''
-        return self._GDictDirect(lat1, lon1, azi1, False, s12, outmask)
+        return self._GDictDirect(lat1, lon1, azi1, False, s12, outmask=outmask)
 
     def Direct3(self, lat1, lon1, azi1, s12):  # PYCHOK outmask
         '''Return the destination lat, lon and reverse azimuth
@@ -355,7 +356,7 @@ class GeodesicExact(_GeodesicBase):
 
            @return: L{Destination3Tuple}C{(lat, lon, final)}.
         '''
-        r = self._GDictDirect(lat1, lon1, azi1, False, s12, Caps._AZIMUTH_LATITUDE_LONGITUDE)
+        r = self._GDictDirect(lat1, lon1, azi1, False, s12, outmask=Caps._AZIMUTH_LATITUDE_LONGITUDE)
         return Destination3Tuple(r.lat2, r.lon2, r.azi2)  # no iteration
 
     def _DirectLine(self, ll1, azi12, s12=0, **caps_name):
@@ -370,10 +371,7 @@ class GeodesicExact(_GeodesicBase):
            @arg lon1: Longitude of the first point (C{degrees}).
            @arg azi1: Azimuth at the first point (compass C{degrees}).
            @arg s12: Distance between the points (C{meter}), can be negative.
-           @kwarg caps: Bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>} values
-                        specifying the capabilities the L{GeodesicLineExact} instance
-                        should possess, i.e., which quantities can be returned by methods
-                        L{GeodesicLineExact.Position}.
+           @kwarg caps: Desired capabilities for the L{GeodesicLineExact} instance.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicLineExact} instance.
@@ -487,7 +485,7 @@ class GeodesicExact(_GeodesicBase):
            @return: A L{GDict} ...
         '''
         C = outmask if arcmode else (outmask | Caps.DISTANCE_IN)
-        glX = self.Line(lat1, lon1, azi1, C | Caps.LINE_OFF)
+        glX = self.Line(lat1, lon1, azi1, caps=C | Caps.LINE_OFF)
         return glX._GDictPosition(arcmode, s12_a12, outmask)
 
     def _GDictInverse(self, lat1, lon1, lat2, lon2, outmask=Caps.STANDARD):  # MCCABE 33, 41 vars
@@ -495,22 +493,23 @@ class GeodesicExact(_GeodesicBase):
 
            @return: A L{GDict} ...
         '''
-        Cs = Caps
+        r, Cs = GDict(), Caps
         if self._debug:  # PYCHOK no cover
             outmask |= Cs._DEBUG_INVERSE & self._debug
+        outmask |= self.caps
         outmask &= Cs._OUT_MASK  # incl. _SALP_CALPs_ and _DEBUG_
-        toNAN = _toNAN(outmask, lat1, lon1, lat2, lon2)
+        if _toNAN(outmask, lat1, lon1, lat2, lon2):
+            return r._toNAN(outmask, lat1=lat1, lon1=lon1, lat2=lat2, lon2=lon2)
+
         # compute longitude difference carefully (with _diff182):
         # result is in [-180, +180] but -180 is only for west-going
         # geodesics, +180 is for east-going and meridional geodesics
         lon12, lon12s = _diff182(lon1, lon2)
         # see C{result} from geographiclib.geodesic.Inverse
         if (outmask & Cs.LONG_UNROLL):  # == (lon1 + lon12) + lon12s
-            r = GDict(lon1=lon1, lon2=fsumf_(lon1, lon12, lon12s))
+            r.set_(lon1=lon1, lon2=fsumf_(lon1, lon12, lon12s))
         elif (outmask & Cs.LONGITUDE):
-            r = GDict(lon1=_norm180(lon1), lon2=_norm180(lon2))
-        else:
-            r = GDict()
+            r.set_(lon1=_norm180(lon1), lon2=_norm180(lon2))
         if _K_2_0:  # GeographicLib 2.0
             # make longitude difference positive
             lon12, lon_ = _unsigned2(lon12)
@@ -543,7 +542,7 @@ class GeodesicExact(_GeodesicBase):
             r.set_(lat1=lat1, lat2=lat2)
         # Swap points so that point with higher (abs) latitude is
         # point 1.  If one latitude is a NAN, then it becomes lat1.
-        swap_ = fabs(lat1) < fabs(lat2) or isnan(lat2)
+        swap_ = isnan(lat2) or fabs(lat1) < fabs(lat2)
         if swap_:
             lat1, lat2 = lat2, lat1
             lon_ = not lon_
@@ -580,7 +579,7 @@ class GeodesicExact(_GeodesicBase):
         p = _PDict(sbet1=sbet1, cbet1=cbet1, dn1=self._dn(sbet1, cbet1),
                    sbet2=sbet2, cbet2=cbet2, dn2=self._dn(sbet2, cbet2))
 
-        _meridian = _b = True  # i.e. not meridian, not b
+        _meridian = _b = True  # i.e. meridian = b = False
         if lat1 == -90 or slam12 == 0:
             # Endpoints are on a single full meridian,
             # so the geodesic might lie on a meridian.
@@ -597,17 +596,18 @@ class GeodesicExact(_GeodesicBase):
             #    echo 20.001 0 20.001 0 | GeodSolve -i
             # In fact, we will have sig12 > PI/2 for meridional
             # geodesic which is not a shortest path.
-            if m12x >= 0 or sig12 < _1_0:
+            if sig12 < _TOL2 or m12x >= 0:  # GeographicLib 2.5.1
                 # Need at least 2 to handle 90 0 90 180
                 # Prevent negative s12 or m12 from geographiclib 1.52
                 if sig12 < _TINY3 or (sig12 < _TOL0 and (s12x < 0 or m12x < 0)):
                     sig12 = m12x = s12x = _0_0
-                else:
-                    _b = False  # apply .b to s12x, m12x
-                _meridian = False
+#               else:
+#                   m12x *= self.b
+#                   s12x *= self.b
+                _meridian = _b = False  # i.e. meridian = b = True
                 C = 1
-            # else:  # m12 < 0, prolate and too close to anti-podal
-            #   _meridian = True
+#           else:  # m12 < 0, prolate and too close to anti-podal
+#               _meridian = True  # i.e. meridian = False
         a12 = _0_0  # if _b else degrees(sig12)
 
         if _meridian:
@@ -651,7 +651,7 @@ class GeodesicExact(_GeodesicBase):
                     if (outmask & Cs.AREA):
                         somg12, comg12 = _sincos2(lam12 / (self.f1 * dnm))
 
-        else:  # _meridian is False
+        else:  # _meridian is False, i.e. meridian is True
             somg12 = comg12 = NAN
 
         r.set_(a12=a12 if _b else degrees(sig12))  # in [0, 180]
@@ -702,8 +702,7 @@ class GeodesicExact(_GeodesicBase):
             p.update(r)  # r overrides p
             r = p.toGDict()
 
-        r = self._iter2tion(r, **p)
-        return r._toNAN(outmask) if toNAN else r
+        return self._iter2tion(r, **p)
 
     def _GenDirect(self, lat1, lon1, azi1, arcmode, s12_a12, outmask=Caps.STANDARD):
         '''(INTERNAL) The general I{Inverse} geodesic calculation.
@@ -711,7 +710,7 @@ class GeodesicExact(_GeodesicBase):
            @return: L{Direct9Tuple}C{(a12, lat2, lon2, azi2,
                                       s12, m12,  M12,  M21, S12)}.
         '''
-        r = self._GDictDirect(lat1, lon1, azi1, arcmode, s12_a12, outmask)
+        r = self._GDictDirect(lat1, lon1, azi1, arcmode, s12_a12, outmask=outmask)
         return r.toDirect9Tuple()
 
     def _GenInverse(self, lat1, lon1, lat2, lon2, outmask=Caps.STANDARD):
@@ -720,7 +719,7 @@ class GeodesicExact(_GeodesicBase):
            @return: L{Inverse10Tuple}C{(a12, s12, salp1, calp1, salp2, calp2,
                                              m12,   M12,   M21,   S12)}.
         '''
-        r = self._GDictInverse(lat1, lon1, lat2, lon2, outmask | Caps._SALP_CALPs_)
+        r = self._GDictInverse(lat1, lon1, lat2, lon2, outmask=outmask | Caps._SALP_CALPs_)
         return r.toInverse10Tuple()
 
     def _Inverse(self, ll1, ll2, wrap, **outmask):
@@ -753,7 +752,7 @@ class GeodesicExact(_GeodesicBase):
                  <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicExact.html>} and
                  Python U{Geodesic.InverseLine<https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
         '''
-        return self._GDictInverse(lat1, lon1, lat2, lon2, outmask)
+        return self._GDictInverse(lat1, lon1, lat2, lon2, outmask=outmask)
 
     def Inverse1(self, lat1, lon1, lat2, lon2, wrap=False):
         '''Return the non-negative, I{angular} distance in C{degrees}.
@@ -765,7 +764,8 @@ class GeodesicExact(_GeodesicBase):
         # and .HeightIDWkarney._distances
         if wrap:
             _, lat2, lon2 = _Wrap.latlon3(lat1, lat2, lon2, True)  # _Geodesic.LONG_UNROLL
-        return fabs(self._GDictInverse(lat1, lon1, lat2, lon2, Caps.EMPTY).a12)  # a12 always
+        r = self._GDictInverse(lat1, lon1, lat2, lon2, outmask=Caps.EMPTY)
+        return fabs(r.a12)  # a12 always
 
     def Inverse3(self, lat1, lon1, lat2, lon2):  # PYCHOK outmask
         '''Return the distance in C{meter} and the forward and
@@ -773,7 +773,7 @@ class GeodesicExact(_GeodesicBase):
 
            @return: L{Distance3Tuple}C{(distance, initial, final)}.
         '''
-        r = self._GDictInverse(lat1, lon1, lat2, lon2, Caps.AZIMUTH_DISTANCE)
+        r = self._GDictInverse(lat1, lon1, lat2, lon2, outmask=Caps.AZIMUTH_DISTANCE)
         return Distance3Tuple(r.s12, wrap360(r.azi1), wrap360(r.azi2),
                               iteration=r.iteration)
 
@@ -791,10 +791,7 @@ class GeodesicExact(_GeodesicBase):
            @arg lon1: Longitude of the first point (C{degrees}).
            @arg lat2: Latitude of the second point (C{degrees}).
            @arg lon2: Longitude of the second point (C{degrees}).
-           @kwarg caps: Bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>} values
-                        specifying the capabilities the L{GeodesicLineExact} instance
-                        should possess, i.e., which quantities can be returned by methods
-                        L{GeodesicLineExact.Position} and L{GeodesicLineExact.ArcPosition}.
+           @kwarg caps: Desired capabilities for the L{GeodesicLineExact} instance.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicLineExact} instance.
@@ -808,7 +805,7 @@ class GeodesicExact(_GeodesicBase):
                  <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicExact.html>} and
                  Python U{Geodesic.InverseLine<https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
         '''
-        r = self._GDictInverse(lat1, lon1, lat2, lon2, caps | Caps._SALP_CALPs_)
+        r = self._GDictInverse(lat1, lon1, lat2, lon2, outmask=caps | Caps._SALP_CALPs_)
         return GeodesicLineExact(self, lat1, lon1, None, caps=caps, _s_calp1=(r.salp1, r.calp1),
                                                             **name)._GenSet(self._debug, **r)
 
@@ -1106,10 +1103,7 @@ class GeodesicExact(_GeodesicBase):
            @arg lat1: Latitude of the first point (C{degrees}).
            @arg lon1: Longitude of the first point (C{degrees}).
            @arg azi1: Azimuth at the first point (compass C{degrees}).
-           @kwarg caps: Bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>} values
-                        specifying the capabilities the L{GeodesicLineExact} instance
-                        should possess, i.e., which quantities can be returned by methods
-                        L{GeodesicLineExact.Position} and L{GeodesicLineExact.ArcPosition}.
+           @kwarg caps: Desired capabilities for the L{GeodesicLineExact} instance.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicLineExact} instance.

pygeodesy/geodesicx/gxarea.py

@@ -31,7 +31,7 @@ from pygeodesy.props import Property, Property_RO, property_RO
 from math import fmod as _fmod
 
 __all__ = ()
-__version__ = '25.06.04'
+__version__ = '25.09.16'
 
 
 class GeodesicAreaExact(_NamedBase):
@@ -74,7 +74,7 @@ class GeodesicAreaExact(_NamedBase):
         self._g_gX = g = geodesic
         # use the class-level Caps since the values
         # differ between GeodesicExact and Geodesic
-        self._mask = g.DISTANCE | g.LATITUDE | g.LONGITUDE
+        self._mask =  g.DISTANCE | g.LATITUDE | g.LONGITUDE
         self._Peri = _Accumulator(name='_Peri')
         if not polyline:  # perimeter and area
             self._mask |=  g.AREA | g.LONG_UNROLL
@@ -188,7 +188,7 @@ class GeodesicAreaExact(_NamedBase):
         '''(INTERNAL) Edge helper.
         '''
         lon1 = self.lon1
-        r = self._g_gX._GDictDirect(self.lat1, lon1, azi, False, s, self._mask)
+        r = self._g_gX._GDictDirect(self.lat1, lon1, azi, False, s, outmask=self._mask)
         if self._Area:  # aka transitDirect
             # Count crossings of prime meridian exactly as
             # int(ceil(lon2 / 360)) - int(ceil(lon1 / 360))
@@ -219,7 +219,7 @@ class GeodesicAreaExact(_NamedBase):
     def _Inverse(self, lat1, lon1, lat2, lon2):
         '''(INTERNAL) Point helper.
         '''
-        r = self._g_gX._GDictInverse(lat1, lon1, lat2, lon2, self._mask)
+        r = self._g_gX._GDictInverse(lat1, lon1, lat2, lon2, outmask=self._mask)
         if self._Area:  # aka transit
             # count crossings of prime meridian as +1 or -1
             # if in east or west direction, otherwise 0

pygeodesy/geodesicx/gxbases.py

@@ -150,11 +150,7 @@ def _sinf1cos2d(lat, f1):
 def _toNAN(outmask, *args):
     '''(INTERNAL) Is any C{arg} not finite?
     '''
-    if (outmask & _CapsBase.NONFINITONAN):  # Caps.NONFINITONAN
-        for arg in args:
-            if not isfinite(arg):
-                return True
-    return False
+    return bool(outmask & _CapsBase.NONFINITONAN) and not all(map(isfinite, args))
 
 
 def _xnC4(**name_nC4):

pygeodesy/geodesicx/gxline.py

@@ -38,9 +38,11 @@ from __future__ import division as _; del _  # noqa: E702 ;
 
 # from pygeodesy.basics import _xinstanceof  # _MODS
 from pygeodesy.constants import NAN, _EPSqrt as _TOL, \
-                               _0_0, _1_0, _180_0, _2__PI, \
-                               _copysign_1_0, isfinite
+                               _copysign_1_0, isfinite, \
+                               _0_0, _1_0, _180_0, _360_0, \
+                               _2__PI  # PYCHOK used!
 from pygeodesy.errors import _xError, _xkwds_pop2
+# from pygeodesy.fmath import fremainder  # from .karney
 from pygeodesy.fsums import fsumf_, fsum1f_
 from pygeodesy.geodesicx.gxbases import _cosSeries, _GeodesicBase, \
                                         _sincos12, _sin1cos2, \
@@ -49,14 +51,14 @@ from pygeodesy.geodesicx.gxbases import _cosSeries, _GeodesicBase, \
 from pygeodesy.lazily import _ALL_DOCS, _ALL_MODS as _MODS
 from pygeodesy.karney import _around, _atan2d, Caps, GDict, _fix90, \
                              _K_2_0, _llz2gl, _norm2, _norm180, \
-                             _sincos2, _sincos2d
+                             _sincos2, _sincos2d,  fremainder
 from pygeodesy.props import Property_RO, property_ROver, _update_all
 from pygeodesy.utily import atan2, atan2d as _atan2d_reverse, sincos2
 
-from math import cos, degrees, fabs, floor, radians, sin
+from math import degrees, fabs, radians
 
 __all__ = ()
-__version__ = '25.05.28'
+__version__ = '25.09.09'
 
 _glXs = []  # instances of C{[_]GeodesicLineExact} to be updated
 
@@ -83,6 +85,7 @@ class _GeodesicLineExact(_GeodesicBase):
     '''
     _a13   = _s13 = NAN
 #   _azi1  = _0_0
+    _caps  =  Caps._AZIMUTH_LATITUDE_LONG_UNROLL
 #   _cchi1 =  NAN
 #   _dn1   =  NAN
     _gX    =  None  # Exact only
@@ -106,7 +109,6 @@ class _GeodesicLineExact(_GeodesicBase):
             salp1, calp1 = _sincos2d(_around(azi1))
         if name_:
             self.name = name_
-        self._toNAN = _toNAN(caps, lat1, lon1, azi1, salp1, calp1)
 
         self._gX    = gX  # GeodesicExact only
         self._lat1  = lat1 = _fix90(lat1)
@@ -115,7 +117,9 @@ class _GeodesicLineExact(_GeodesicBase):
         self._salp1 = salp1
         self._calp1 = calp1
         # allow lat, azimuth and unrolling of lon
-        self._caps  = caps | Caps._AZIMUTH_LATITUDE_LONG_UNROLL
+        self._caps |= caps | gX.caps  # | Caps._AZIMUTH_LATITUDE_LONG_UNROLL
+
+        self._toNAN = _toNAN(self._caps, lat1, lon1, azi1, salp1, calp1)
 
         sbet1, cbet1 = _sinf1cos2d(_around(lat1), gX.f1)
         self._dn1 = gX._dn(sbet1, cbet1)
@@ -282,8 +286,11 @@ class _GeodesicLineExact(_GeodesicBase):
     def _eF(self):
         '''(INTERNAL) Cached/memoized C{Elliptic} function.
         '''
-        # see .gx.GeodesicExact._ef_reset_k2
-        return _MODS.elliptic.Elliptic(k2=-self._k2, alpha2=-self.geodesic.ep2)
+        e = _MODS.elliptic
+        try:  # see .gx.GeodesicExact._ef_reset_k2
+            return e.Elliptic(k2=-self._k2, alpha2=-self.geodesic.ep2)
+        except e.EllipticError:  # nonfinite
+            return None
 
     def _GDictPosition(self, arcmode, s12_a12, outmask=Caps.STANDARD):  # MCCABE 17
         '''(INTERNAL) Generate a new position along the geodesic.
@@ -293,26 +300,27 @@ class _GeodesicLineExact(_GeodesicBase):
                     C{lon1}, C{azi1} and arc length C{a12} always included,
                     except when C{a12=NAN}.
         '''
-        Cs = Caps
+        r, Cs = GDict(), Caps
         if outmask:
             outmask &= self._caps & Cs._OUT_MASK
         eF = self._eF
+        if eF is None or self._toNAN or not isfinite(s12_a12):  # _toNAN(outmask, s12_a12)?
+            # E2 = sig12 = ssig12 = csig12 = NAN
+            d = dict(a12=s12_a12) if arcmode else dict(s12=s12_a12)
+            return r._toNAN(outmask | Cs.NONFINITONAN,  # for backward compatibility
+                            lat1=self.lat1, lon1=self.lon1, azi1=self.azi1, **d)
         gX = self.geodesic  # ._gX
-        r  = GDict(a12=NAN, s12=NAN)  # both a12 and s12, always
 
-        if self._toNAN or not isfinite(s12_a12):  # _toNAN(outmask, s12_a12)?
-            # E2 = sig12 = ssig12 = csig12 = NAN
-            return r._toNAN(outmask | Cs.NONFINITONAN)  # for backward compatibility
-        elif arcmode:  # s12_a12 is (spherical) arc length
-            r.set_(a12=s12_a12)
+        if arcmode:  # s12_a12 is (spherical) arc length
+            r.set_(a12=s12_a12, s12=NAN)
             sig12 = radians(s12_a12)
-            if _K_2_0:
-                ssig12, csig12 = sincos2(sig12)  # utily, no NEG0
-            else:  # PYCHOK no cover
-                a  = fabs(s12_a12)  # 0 <= fabs(_remainder(s12_a12, _180_0)) <= 90
-                a -= floor(a / _180_0) * _180_0  # 0 <= 0 < 180
-                ssig12 = _0_0 if a ==  0 else sin(sig12)
-                csig12 = _0_0 if a == 90 else cos(sig12)
+            ssig12, csig12 = sincos2(sig12)  # utily, no NEG0
+            if not _K_2_0:  # PYCHOK no cover
+                d = fremainder(fabs(s12_a12), _180_0)
+                if d == 90:
+                    csig12 = _0_0
+                elif d == 0:
+                    ssig12 = _0_0
             E2 = _0_0
         elif self._caps_DISTANCE_IN:  # s12_a12 is distance
             t = s12_a12 / self._E0b
@@ -321,9 +329,9 @@ class _GeodesicLineExact(_GeodesicBase):
             E2 = -eF.deltaEinv(*_sincos12(-s, c, *self._stau1_ctau1))
             sig12 = fsum1f_(self._E1, -E2, t)  # == t - (E2 - E1)
             ssig12, csig12 = _sincos2(sig12)
-            r.set_(a12=degrees(sig12))
+            r.set_(a12=degrees(sig12), s12=s12_a12)
         else:  # uninitialized or impossible distance requested
-            return r
+            return r.set_(a12=NAN, s12=NAN)
 
         # sig2 = sig1 + sig12
         ssig1, csig1 =      self._ssig1, self._csig1
@@ -331,7 +339,6 @@ class _GeodesicLineExact(_GeodesicBase):
         dn2 = eF.fDelta(*t)
 
         if (outmask &  Cs.DISTANCE):
-            outmask ^= Cs.DISTANCE
             if arcmode:  # or f_0_01
                 E2 = eF.deltaE(ssig2, csig2, dn2)
                 # AB1 = _E0 * (E2 - _E1)
@@ -343,7 +350,7 @@ class _GeodesicLineExact(_GeodesicBase):
                 s12 = s12_a12
             r.set_(s12=s12)
 
-        if not outmask:  # all done, see ._GenSet
+        if not (outmask ^ Cs.DISTANCE):  # all done, see ._GenSet
             return r
 
         if self._debug:  # PYCHOK no cover
@@ -374,17 +381,19 @@ class _GeodesicLineExact(_GeodesicBase):
         if (outmask & Cs.LONGITUDE):
             schi1 = self._somg1
             cchi1 = self._cchi1
-            schi2 = ssig2 * salp0
-            cchi2 = gX.f1 * dn2 * csig2  # schi2 = somg2 without normalization
+            schi2 = ssig2 * salp0  # schi2 = somg2 without normalization
+            cchi2 = gX.f1 * dn2 * csig2
             lam12 = salp0 * self._H0e2_f1 * fsum1f_(eF.deltaH(ssig2, csig2, dn2),
                                                     -self._H1, sig12)
             if (outmask & Cs.LONG_UNROLL):
-                t = _copysign_1_0(salp0)  # east-going?
-                tchi1 = t * schi1
-                tchi2 = t * schi2
-                chi12 = t * fsum1f_(atan2(ssig1, csig1), -atan2(ssig2, csig2),
+                e = _copysign_1_0(salp0)  # east-going?
+                tchi1 = e * schi1
+                tchi2 = e * schi2
+                chi12 = e * fsum1f_(atan2(ssig1, csig1), -atan2(ssig2, csig2),
                                     atan2(tchi2, cchi2), -atan2(tchi1, cchi1), sig12)
                 lon2  = self.lon1 + degrees(chi12 - lam12)
+                if fabs(lon2) > _360_0:  # XXX kludge
+                    lon2 = _norm180(lon2)
             else:
                 chi12 = atan2(*_sincos12(schi1, cchi1, schi2, cchi2))
                 lon2 = _norm180(self._lon1_norm180 + _norm180(degrees(chi12 - lam12)))
@@ -398,7 +407,7 @@ class _GeodesicLineExact(_GeodesicBase):
             J12 = self._D0k2 * fsumf_(eF.deltaD(ssig2, csig2, dn2), -self._D1, sig12)
             if (outmask & Cs._DEBUG_DIRECT_LINE):  # PYCHOK no cover
                 r.set_(ssig1=ssig1, dn1=dn1, D0k2=self._D0k2,
-                       csig1=csig1, J12=J12, D1=self._D1)
+                       csig1=csig1, dn2=dn2, D1=self._D1, J12=J12)
             if (outmask & Cs.REDUCEDLENGTH):
                 # Add parens around (csig1 * ssig2) and (ssig1 * csig2) to
                 # ensure accurate cancellation in the case of coincident points.

pygeodesy/geodsolve.py

@@ -16,14 +16,13 @@ from pygeodesy.interns import _DMAIN_, NN, _UNDER_
 from pygeodesy.karney import Caps, GeodesicError, GeodSolve12Tuple, \
                             _sincos2d, _Xables,  _0_0, NAN
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _name1__
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
 from pygeodesy.props import Property, Property_RO, property_RO
 from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '25.04.14'
+__version__ = '25.09.03'
 
 
 class _GeodesicSolveBase(_SolveGDictBase):
@@ -131,18 +130,15 @@ class GeodesicSolve(_GeodesicSolveBase):
         '''
         return self.DirectLine(ll1.lat, ll1.lon, azi12, **caps_name)
 
-    def DirectLine(self, lat1, lon1, azi1, **caps_name):
+    def DirectLine(self, lat1, lon1, azi1, caps=Caps.ALL, **name):
         '''Set up a L{GeodesicLineSolve} to compute several points
            on a single geodesic.
 
            @arg lat1: Latitude of the first point (C{degrees}).
            @arg lon1: Longitude of the first point (C{degrees}).
            @arg azi1: Azimuth at the first point (compass C{degrees}).
-           @kwarg caps_name: Optional C{B{name}=NN} (C{str}) and keyword
-                       argument C{B{caps}=Caps.ALL}, bit-or'ed combination
-                       of L{Caps<pygeodesy.karney.Caps>} values specifying
-                       the capabilities the L{GeodesicLineSolve} instance
-                       should possess.
+           @kwarg caps: Desired capabilities for the L{GeodesicLineSolve} instance.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicLineSolve} instance.
 
@@ -154,9 +150,9 @@ class GeodesicSolve(_GeodesicSolveBase):
                  <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicExact.html>}
                  and Python U{Geodesic.Line<https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
         '''
-        return GeodesicLineSolve(self, lat1, lon1, azi1, **_name1__(caps_name, _or_nameof=self))
+        return GeodesicLineSolve(self, lat1, lon1, azi1, caps=caps, **name)
 
-    Line = DirectLine
+    Line = ArcDirectLine = DirectLine
 
     def _Inverse(self, ll1, ll2, wrap, **outmask):  # PYCHOK no cover
         '''(INTERNAL) Short-cut version, see .ellipsoidalBaseDI.intersecant2.
@@ -182,7 +178,7 @@ class GeodesicSolve(_GeodesicSolveBase):
             ll2 = _unrollon(ll1, _Wrap.point(ll2))
         return self.InverseLine(ll1.lat, ll1.lon, ll2.lat, ll2.lon, **caps_name)
 
-    def InverseLine(self, lat1, lon1, lat2, lon2, **caps_name):  # PYCHOK no cover
+    def InverseLine(self, lat1, lon1, lat2, lon2, caps=Caps.ALL, **name):  # PYCHOK no cover
         '''Set up a L{GeodesicLineSolve} to compute several points
            on a single geodesic.
 
@@ -190,11 +186,8 @@ class GeodesicSolve(_GeodesicSolveBase):
            @arg lon1: Longitude of the first point (C{degrees}).
            @arg lat2: Latitude of the second point (C{degrees}).
            @arg lon2: Longitude of the second point (C{degrees}).
-           @kwarg caps_name: Optional C{B{name}=NN} (C{str}) and keyword
-                       argument C{B{caps}=Caps.ALL}, bit-or'ed combination
-                       of L{Caps<pygeodesy.karney.Caps>} values specifying
-                       the capabilities the L{GeodesicLineSolve} instance
-                       should possess.
+           @kwarg caps: Desired capabilities for the L{GeodesicLineSolve} instance.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicLineSolve} instance.
 
@@ -205,7 +198,7 @@ class GeodesicSolve(_GeodesicSolveBase):
                  Python U{Geodesic.InverseLine<https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
         '''
         r  = self.Inverse(lat1, lon1, lat2, lon2)
-        gl = GeodesicLineSolve(self, lat1, lon1, r.azi1, **_name1__(caps_name, _or_nameof=self))
+        gl = GeodesicLineSolve(self, lat1, lon1, r.azi1, caps=caps, **name)
         gl._a13 = r.a12  # gl.SetArc(r.a12)
         gl._s13 = r.s12  # gl.SetDistance(r.s12)
         return gl

pygeodesy/geohash.py

@@ -37,7 +37,7 @@ from pygeodesy.units import Degrees_, Int, Lat_, Lon_, Meter, Precision_, Str
 from math import fabs, ldexp, log10, radians
 
 __all__ = _ALL_LAZY.geohash
-__version__ = '25.04.21'
+__version__ = '25.09.16'
 
 _formy   = _MODS.into(formy=__name__)
 _MASK5   =  16, 8, 4, 2, 1  # PYCHOK used!
@@ -150,10 +150,10 @@ class _GH(object):
         '''
         def _encodes(lat, lon, prec, eps=0):
             s, w, n, e = self.SWNE4
-            E, d, _mid = self.EncodeB32, True, _2mid
+            d, _mid = True, _2mid
             for _ in range(prec):
                 i = 0
-                for _ in range(5):  # len(_MASK5)
+                for _ in _MASK5:
                     i += i
                     if d:  # bisect longitude
                         a = _mid(e, w)
@@ -170,7 +170,7 @@ class _GH(object):
                             s  = a
                             i += 1
                     d = not d
-                yield E[i]
+                yield self.EncodeB32[i]
                 if eps > 0:  # infer prec
                     if _2dab(lon, e, w) < eps and \
                        _2dab(lat, n, s) < eps:
@@ -233,10 +233,10 @@ class _GH(object):
         if not (0 < nc <= _MaxPrec):  # or geohash.startswith(_INV_)
             raise GeohashError(geohash=geohash, len=nc)
         s, w, n, e = self.SWNE4
-        D, d, _mid = self.DecodeB32, True, _2mid
+        d, _mid = True, _2mid
         try:
             for j, c in enumerate(geohash.lower()):
-                i = D[c]
+                i = self.DecodeB32[c]
                 for m in mask5:
                     if d:  # longitude
                         a = _mid(e, w)

pygeodesy/geoids.py

@@ -28,7 +28,7 @@ or L{GeoidPGM} and download a C{geoid} model file, containing locations with
 known heights also referred to as the C{grid knots}.  See the documentation of
 the interpolator class for references to available C{grid} models.
 
-C{>>> from pygeodesy import GeoidEGM96  # or -G2012B, -Karney or -PGM as GeoidXyz}
+C{>>> from pygeodesy import GeoidEGM96 as GeoidXyz  # or GeoidG2012B, -Karney or -PGM}
 
 2. Instantiate an interpolator with the C{geoid} model file and use keyword
 arguments to select different interpolation options
@@ -126,7 +126,7 @@ except ImportError:  # Python 3+
     from io import BytesIO as _BytesIO  # PYCHOK expected
 
 __all__ = _ALL_LAZY.geoids
-__version__ = '25.05.21'
+__version__ = '25.09.26'
 
 _assert_    = 'assert'
 _bHASH_     = b'#'

pygeodesy/heights.py

@@ -21,7 +21,7 @@ C{>>> ...}
 
 2. Select one of the C{Height} classes for height interpolation
 
-C{>>> from pygeodesy import HeightCubic  # or other Height... as HeightXyz}
+C{>>> from pygeodesy import HeightCubic as HeightXyz  # or an other Height... class}
 
 3. Instantiate a height interpolator with the C{knots} and use keyword
 arguments to select different interpolation options
@@ -92,7 +92,7 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '25.05.26'
+__version__ = '25.09.29'
 
 _error_  = 'error'
 _formy   = _MODS.into(formy=__name__)