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

pygeodesy/elliptic.py

@@ -75,7 +75,7 @@ U{22<https://DLMF.NIST.gov/22>}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # noqa: E702 ;
 
-from pygeodesy.basics import copysign0, map2, neg, neg_,  typename
+from pygeodesy.basics import copysign0, map2, neg, neg_
 from pygeodesy.constants import EPS, INF, NAN, PI, PI_2, PI_4, \
                                _EPStol as _TolJAC, _0_0, _0_25, \
                                _0_5, _1_0, _2_0, _N_2_0, _3_0, \
@@ -85,7 +85,7 @@ from pygeodesy.constants import _EPSjam as _TolJAM  # PYCHOK used!
 # from pygeodesy.errors import _ValueError  # from .fsums
 from pygeodesy.fmath import favg, Fdot_, fma, hypot1, zqrt
 from pygeodesy.fsums import Fsum, _fsum,  _ValueError
-# from pygeodesy.internals import typename  # from .basics
+from pygeodesy.internals import _Enum, typename
 from pygeodesy.interns import NN, _delta_, _DOT_, _f_, _invalid_, \
                              _invokation_, _negative_, _SPACE_
 from pygeodesy.karney import _K_2_0, _norm180, _signBit, _sincos2
@@ -100,7 +100,7 @@ from math import asin, asinh, atan, ceil, cosh, fabs, floor, radians, \
                  sin, sinh, sqrt, tan, tanh  # tan as _tan
 
 __all__ = _ALL_LAZY.elliptic
-__version__ = '25.06.02'
+__version__ = '25.09.04'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
@@ -108,13 +108,10 @@ _TolRG0 = _TolJAC   * 2.7
 _TRIPS  =  28  # Max depth, 6-18 might be sufficient
 
 
-class _Cs(object):
-    '''(INTERAL) Complete integrals cache.
+class _Cs(_Enum):
+    '''(INTERAL) Complete Integrals cache.
     '''
-    def __init__(self, **kwds):
-        # for n,v in kwds.items():
-        #     setattr(self, n, v)
-        self.__dict__ = kwds
+    pass
 
 
 class Elliptic(_Named):
@@ -773,8 +770,8 @@ class Elliptic(_Named):
         def _S(**kwds):
             return Scalar_(Error=EllipticError, **kwds)
 
-        self._k2      = _S(k2 = k2, low=None, high=_1_0)
-        self._kp2     = _S(kp2=_1p2(kp2, k2))  # low=_0_0
+        self._k2  = _S(k2 = k2, low=None, high=_1_0)
+        self._kp2 = _S(kp2=_1p2(kp2, k2))  # low=_0_0
 
         self._alpha2  = _S(alpha2 = alpha2, low=None, high=_1_0)
         self._alphap2 = _S(alphap2=_1p2(alphap2, alpha2))  # low=_0_0

pygeodesy/errors.py

@@ -16,9 +16,10 @@ C{PYGEODESY_EXCEPTION_CHAINING=std} or to any non-empty string.
 # from pygeodesy import errors  # _MODS, _MODS.getattr
 from pygeodesy.internals import _envPYGEODESY, _plural, _tailof, typename
 from pygeodesy.interns import MISSING, NN, _a_, _an_, _and_, _clip_, _COLON_, _COLONSPACE_, \
-                             _COMMASPACE_, _datum_, _ELLIPSIS_, _ellipsoidal_, _incompatible_, \
-                             _invalid_, _keyword_, _LatLon_, _len_, _not_, _or_, _SPACE_, \
-                             _specified_, _UNDER_, _vs_, _with_
+                             _COMMASPACE_, _datum_, _DOT_, _ELLIPSIS_, _ellipsoidal_, \
+                             _EQUALSPACED_, _immutable_, _incompatible_, _invalid_, _keyword_, \
+                             _LatLon_, _len_, _not_, _or_, _SPACE_, _specified_, _UNDER_, \
+                             _vs_, _with_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYTHON_X_DEV
 # from pygeodesy import streprs as _streprs  # _MODS.into
 # from pygeodesy.unitsBase import Str  # _MODS
@@ -27,11 +28,12 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYTHON_X_DEV
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '25.05.19'
+__version__ = '25.09.04'
 
 _argument_   = 'argument'
 _basics      = _MODS.into(basics=__name__)
 _box_        = 'box'
+_del_        = 'del'
 _expected_   = 'expected'
 _limiterrors =  True  # in .formy
 _name_value_ =  repr('name=value')
@@ -224,7 +226,8 @@ class IntersectionError(_ValueError):  # in .ellipsoidalBaseDI, .formy, ...
         '''New L{IntersectionError}.
         '''
         if args:
-            _ValueError.__init__(self, _SPACE_(*args), **kwds)
+            t = _COMMASPACE_(*map(repr, args))
+            _ValueError.__init__(self, t, **kwds)
         else:
             _ValueError.__init__(self, **kwds)
 
@@ -474,6 +477,16 @@ def exception_chaining(exc=None):
             getattr(exc, '__cause__', None)  # _DCAUSE_
 
 
+def _ImmutableError(inst, attr, value=_del_, Error=_TypeError):  # PYCHOK self
+    '''(INTERNAL) Format an C{immutable _TypeError}.
+    '''
+    n =  typename(inst)
+    n = _DOT_(_xattr(inst, name=n), attr)
+    t = _SPACE_(_del_, n) if value is _del_ else \
+        _EQUALSPACED_(n, repr(value))
+    return Error(_immutable_, txt=t)
+
+
 def _incompatible(this):
     '''(INTERNAL) Format an C{"incompatible with ..."} text.
     '''

pygeodesy/etm.py

@@ -75,8 +75,8 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  _EWGS84
 # from pygeodesy.fsums import Fsum  # from .fmath
 from pygeodesy.fmath import cbrt, hypot, hypot1, hypot2,  Fsum
 from pygeodesy.interns import _COMMASPACE_, _DMAIN_, _near_, _SPACE_, _spherical_
-from pygeodesy.karney import _K_2_4, _copyBit, _diff182, _fix90, _norm2, \
-                            _norm180, _tand, _unsigned2
+from pygeodesy.karney import _K_2_4, _diff182, _fix90, _norm2, _norm180, \
+                             _signBit, _tand, _unsigned2
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
 from pygeodesy.named import callername, _incompatible, _NamedBase, \
                            _ALL_LAZY, _MODS
@@ -93,7 +93,7 @@ from pygeodesy.utm import _cmlon, _LLEB, _parseUTM5, _toBand, _toXtm8, \
 from math import asinh, degrees, radians, sinh, sqrt
 
 __all__ = _ALL_LAZY.etm
-__version__ = '25.05.12'
+__version__ = '25.08.31'
 
 _OVERFLOW = _1_EPS**2  # ~2e+31
 _TAYTOL   =  pow(EPS,  0.6)
@@ -790,7 +790,7 @@ class ExactTransverseMercator(_NamedBase):
             mu = mu / d2
             mv = mv / d2
         else:
-            mu, mv = map1(_overflow, mu, mv)
+            mu, mv = map1(_copysignOVERFLOW, mu, mv)
         xi = self._Eu.fE(snu, cnu, dnu) - mu
         v -= self._Ev.fE(snv, cnv, dnv) - mv
         return xi, v, d2
@@ -910,12 +910,12 @@ class ExactTransverseMercator(_NamedBase):
         if d1 > EPS02:  # _EPSmin
             t1 = snu * dnv / sqrt(d1)
         else:  # like atan(overflow) = pi/2
-            t1, d1 = _overflow(snu), 0
+            t1, d1 = _copysignOVERFLOW(snu), 0
         d2 = cnu2 * self._mu + cnv**2 * mv
         if d2 > EPS02:  # _EPSmin
             t2 = sinh(e * asinh(e * snu / sqrt(d2)))
         else:
-            t2, d2 = _overflow(snu), 0
+            t2, d2 = _copysignOVERFLOW(snu), 0
         # psi = asinh(t1) - asinh(t2)
         # taup = sinh(psi)
         taup = t1 * hypot1(t2) - t2 * hypot1(t1)
@@ -1026,10 +1026,10 @@ _allPropertiesOf_n(22, ExactTransverseMercator, Property_RO)  # PYCHOK assert _R
 del _0_1, _allPropertiesOf_n, EPS, _1_EPS, _EWGS84
 
 
-def _overflow(x):
+def _copysignOVERFLOW(x):
     '''(INTERNAL) Like C{copysign0(OVERFLOW, B{x})}.
     '''
-    return _copyBit(_OVERFLOW, x)
+    return (-_OVERFLOW) if _signBit(x) else _OVERFLOW
 
 
 def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, **name):

pygeodesy/fmath.py

@@ -25,7 +25,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '25.06.03'
+__version__ = '25.08.31'
 
 # sqrt(2) - 1 <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ~ 3_730_904_090_310_553 / 9_007_199_254_740_992

pygeodesy/geodesicx/__init__.py

@@ -23,7 +23,7 @@ from pygeodesy.karney import Caps, GeodesicError
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 
 __all__ = _ALL_LAZY.geodesicx + _ALL_DOCS(Caps, GeodesicError)
-__version__ = '25.06.04'
+__version__ = '25.09.02'
 
 # **) MIT License
 #

pygeodesy/geodesicx/__main__.py

@@ -46,6 +46,7 @@ def _main(**C4order):  # PYCHOK no cover
 from sys import argv  # .internals._isPyChOK
 _main(C4order=int(argv[1])) if len(argv) == 2 and argv[1].isdigit() else _main()
 
+
 # % python3.13 -m pygeodesy.geodesicx
 # pygeodesy.geodesicx 25.06.01: C4order=30, C4n=5425, C4u=5107, C4u_n=94.1%, C4x=465, C4t=tuple, C4z=166008, geographiclib 2.0 (pygeodesy 25.5.28 Python 3.13.3 64bit arm64 macOS 15.5)
 

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.02'
 
 _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
 
@@ -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.
@@ -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.
@@ -791,10 +790,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.
@@ -1106,10 +1102,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/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