pygeodesy 25.7.25__py2.py3-none-any.whl → 25.9.9__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.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

pygeodesy/internals.py

@@ -4,10 +4,10 @@
 u'''Mostly INTERNAL functions, except L{machine}, L{print_} and L{printf}.
 '''
 # from pygeodesy.basics import isiterablen, ubstr  # _MODS
-# from pygeodesy.errors import _AttributeError, _error_init, _UnexpectedError, _xError2  # _MODS
-from pygeodesy.interns import _BAR_, _COLON_, _DASH_, _DMAIN_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
-                              _immutable_, _NL_, NN, _pygeodesy_, _PyPy__, _python_, _QUOTE1_, \
-                              _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_
+# from pygeodesy.errors import _AttributeError, _error_init, _ImmutableError, _UnexpectedError, _xError2  # _MODS
+from pygeodesy.interns import _BAR_, _COLON_, _DASH_, _DMAIN_, _DOT_, _ELLIPSIS_, _NL_, NN, \
+                              _pygeodesy_, _PyPy__, _python_, _QUOTE1_, _QUOTE2_, _s_, _sys, \
+                              _SPACE_, _UNDER_
 from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # from pygeodesy.streprs import anstr, pairs, unstr  # _MODS
 
@@ -56,6 +56,27 @@ def _Property_RO(method):
     return property(_get, _set, _del)
 
 
+class _Enum(object):  # in .elliptic, .utily
+    '''(INTERNAL) Enum-like, immutable items.
+    '''
+    # _ImmutableError = None
+
+    def __init__(self, **enums):
+        self.__dict__.update(enums)
+        # for item in enums.items():
+        #     setattr(self, *item)  # object.__setattr__
+
+    def __str__(self):
+        _unstr = _MODS.streprs.unstr
+        return _unstr(_Enum, **self.__dict__)
+
+    # def __delattr__(self, attr):  # PYCHOK no cover
+        # raise _ImmutableError(self, attr)  # _del_
+
+    # def __setattr__(self, attr, value):  # PYCHOK no cover
+        # raise _ImmutableError(self, attr, value)
+
+
 class _MODS_Base(object):
     '''(INTERNAL) Base-class for C{lazily._ALL_MODS}.
     '''
@@ -63,10 +84,7 @@ class _MODS_Base(object):
         self.__dict__.pop(attr, None)
 
     def __setattr__(self, attr, value):  # PYCHOK no cover
-        e = _MODS.errors
-        n = _DOT_(self.name, attr)
-        t = _EQUALSPACED_(n, repr(value))
-        raise e._AttributeError(_immutable_, txt=t)
+        raise _ImmutableError(self, attr, value)
 
     @_Property_RO
     def basics(self):
@@ -76,7 +94,7 @@ class _MODS_Base(object):
         return b
 
     @_Property_RO
-    def bits_machine2(self):
+    def bits_machine2(self):  # in test/bases.py
         '''Get platform 2-list C{[bits, machine]}, I{once}.
         '''
         import platform as p
@@ -302,6 +320,12 @@ def _headof(name):
     return name if i < 0 else name[:i]
 
 
+def _ImmutableError(*inst_attr_value):
+    '''(INTERNAL) Format an C{_ImmutableError}.
+    '''
+    return _MODS.errors._ImmutableError(*inst_attr_value)
+
+
 # def _is(a, b):  # PYCHOK no cover
 #     '''(INTERNAL) C{a is b}? in C{PyPy}
 #     '''
@@ -473,10 +497,10 @@ def printf(fmt, *args, **nl_nt_prec_prefix__end_file_flush_sep__kwds):
         else:
             t =  fmt
     except Exception as x:
-        _E, s = _MODS.errors._xError2(x)
-        unstr = _MODS.streprs.unstr
-        t = unstr(printf, fmt, *args, **nl_nt_prec_prefix__end_file_flush_sep__kwds)
-        raise _E(s, txt=t, cause=x)
+        _Error, s = _MODS.errors._xError2(x)
+        _unstr    = _MODS.strepr.unstr
+        t = _unstr(printf, fmt, *args, **nl_nt_prec_prefix__end_file_flush_sep__kwds)
+        raise _Error(s, txt=t, cause=x)
     try:
         n = f.write(NN(b, t, e))
     except UnicodeEncodeError:  # XXX only Windows
@@ -686,7 +710,7 @@ def _versions(sep=_SPACE_):
 
 
 __all__ = tuple(map(typename, (machine, print_, printf, typename)))
-__version__ = '25.05.26'
+__version__ = '25.09.05'
 
 if __name__ == _DMAIN_:
 
@@ -699,7 +723,7 @@ if __name__ == _DMAIN_:
     _main()
 
 # % python3 -m pygeodesy.internals
-# pygeodesy 25.4.14 Python 3.13.2 64bit arm64 macOS 15.4 _isfrozen False isLazy 1
+# pygeodesy 25.8.18 Python 3.13.5 64bit arm64 macOS 15.6 _isfrozen False isLazy 1
 
 # **) MIT License
 #

pygeodesy/karney.py

@@ -157,8 +157,7 @@ from pygeodesy.interns import NN, _a12_, _area_, _azi1_, _azi2_, _azi12_, \
                              _SPACE_, _UNDER_, _X_, _1_, _2_,  _BAR_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS
 from pygeodesy.named import ADict, _NamedBase, _NamedTuple, notImplemented, _Pass
-from pygeodesy.props import deprecated_method, Property_RO, property_RO, \
-                                               property_ROnce
+from pygeodesy.props import deprecated_method, property_RO, property_ROnce
 from pygeodesy.units import Azimuth as _Azi, Degrees as _Deg, Lat, Lon, \
                             Meter as _M, Meter2 as _M2, Number_
 from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
@@ -166,7 +165,7 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '25.05.28'
+__version__ = '25.08.31'
 
 _2_4_       = '2.4'
 _K_2_0      = _getenv(_PYGEODESY_ENV(typename(_xgeographiclib)[2:]), _2_)
@@ -270,16 +269,16 @@ class Caps(object):
     REDUCEDLENGTH =  1 << 12 | _CAP_1 | _CAP_2  # compute reduced length C{m12}
     GEODESICSCALE =  1 << 13 | _CAP_1 | _CAP_2  # compute geodesic scales C{M12} and C{M21}
     AREA          =  1 << 14 | _CAP_4  # compute area C{S12}
+    ALL           =  0x7F80  | _CAP_ALL  # without LONG_UNROLL, LINE_OFF, NONFINITONAN, REVERSE2 and _DEBUG_*
 
     STANDARD      =  AZIMUTH  | DISTANCE | LATITUDE | LONGITUDE
     STANDARD_LINE =  STANDARD | DISTANCE_IN  # for goedesici/-w
 
     LINE_CAPS     =  STANDARD_LINE | REDUCEDLENGTH | GEODESICSCALE  # .geodesici only
     LONG_UNROLL   =  1 << 15  # unroll C{lon2} in .Direct and .Position
-    NONFINITONAN  =  1 << 16  # see method GDict._toNAN
-    LINE_OFF      =  1 << 17  # Line without updates from parent geodesic or rhumb
+    LINE_OFF      =  1 << 16  # Line without updates from parent geodesic or rhumb
+    NONFINITONAN  =  1 << 17  # see method GDict._toNAN
     REVERSE2      =  1 << 18  # reverse C{azi2}
-    ALL           =  0x7F80 | _CAP_ALL  # without LONG_UNROLL, LINE_OFF, REVERSE2 and _DEBUG_*
 
     AZIMUTH_DISTANCE        = AZIMUTH | DISTANCE
     AZIMUTH_DISTANCE_AREA   = AZIMUTH | DISTANCE | AREA
@@ -300,7 +299,7 @@ class Caps(object):
     _INVERSE3      =  AZIMUTH  | DISTANCE  # for goedesicw only
 
     _OUT_ALL       =  ALL  # see geographiclib.geodesiccapabilities.py
-    _OUT_MASK      =  ALL | LONG_UNROLL | REVERSE2 | _DEBUG_ALL
+    _OUT_MASK      =  ALL | LONG_UNROLL | NONFINITONAN | REVERSE2 | _DEBUG_ALL
 
     _AZIMUTH_LATITUDE_LONGITUDE           =  AZIMUTH | LATITUDE | LONGITUDE
     _AZIMUTH_LATITUDE_LONG_UNROLL         =  AZIMUTH | LATITUDE | LONG_UNROLL
@@ -366,7 +365,7 @@ class _CapsBase(_NamedBase):  # in .auxilats, .geodesicx.gxbases
     _caps         = 0  # None
     _debug        = 0  # or Caps._DEBUG_...
 
-    @Property_RO
+    @property_RO
     def caps(self):
         '''Get the capabilities (bit-or'ed C{Caps}).
         '''
@@ -455,13 +454,16 @@ class GDict(ADict):  # XXX _NamedDict
         '''
         return self._toTuple(Inverse10Tuple, dflt)
 
-    def _toNAN(self, outmask):  # .GeodesicExact._GDistInverse, .GeodesicLineExact._GenPosition
+    def _toNAN(self, outmask, **specs):  # .GeodesicExact._GDistInverse, .GeodesicLineExact._GenPosition
         '''(INTERNAL) Convert this C{GDict} to all C{NAN}s.
         '''
         if (outmask & Caps.NONFINITONAN):
-            d = dict((k, NAN) for k, C in _key2Caps.items()
-                                       if (outmask & C) == C)
-            self.set_(**d)
+            def _t2(k):
+                return k, specs.get(k, NAN)
+
+            d = dict(_t2(k) for k, C in _key2Caps.items()
+                                     if (outmask & C) == C)
+            self.set_(**d)  # self.update(d)
         return self
 
     @deprecated_method
@@ -721,12 +723,11 @@ def _around(x):  # in .utily.sincos2d
     try:
         return _wrapped.Math.AngRound(x)
     except AttributeError:
-        if x:
-            y = _1_16th - fabs(x)
-            if y > 0:  # fabs(x) < _1_16th
-                x = _copysign(_1_16th - y, x)
-        else:
-            x = _0_0  # -0 to 0
+        b, a = _1_16th, fabs(x)
+        if a < b:
+            a -= b
+            a += b
+            x = _copysign(a, x)
         return x