pygeodesy 25.5.5__py2.py3-none-any.whl → 25.5.28__py2.py3-none-any.whl

pygeodesy/fsums.py

@@ -37,7 +37,7 @@ respectively C{ValueError} exceptions.  However, in that case I{non-finite}
 results may differ from Python's C{math.fsum} results.
 '''
 # make sure int/int division yields float quotient, see .basics
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _gcd, isbool, iscomplex, isint, isscalar, \
                              _signOf, itemsorted, signOf, _xiterable
@@ -48,7 +48,7 @@ from pygeodesy.errors import _AssertionError, _OverflowError, _TypeError, \
                              _ValueError, _xError, _xError2, _xkwds, \
                              _xkwds_get, _xkwds_get1, _xkwds_not, \
                              _xkwds_pop, _xsError
-from pygeodesy.internals import _enquote, _envPYGEODESY, _passarg, typename
+from pygeodesy.internals import _enquote, _envPYGEODESY, _passarg, typename  # _sizeof
 from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DMAIN_, _DOT_, _from_, \
                              _not_finite_, _SPACE_, _std_, _UNDER_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
@@ -64,7 +64,7 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '25.04.26'
+__version__ = '25.05.12'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -230,13 +230,13 @@ def f2product(two=None):
 def _Fsumf_(*xs):  # in .auxLat, ...
     '''(INTERNAL) An C{Fsum(xs)}, all C{scalar}, an L{Fsum} or L{Fsum2Tuple}.
     '''
-    return Fsum()._facc_scalarf(xs, up=False)
+    return Fsum()._facc_xsum(xs, up=False)
 
 
 def _Fsum1f_(*xs):  # in .albers
     '''(INTERNAL) An C{Fsum(xs)}, all C{scalar}, an L{Fsum} or L{Fsum2Tuple}, 1-primed.
     '''
-    return Fsum()._facc_scalarf(_1primed(xs), origin=-1, up=False)
+    return Fsum()._facc_xsum(_1primed(xs), origin=-1, up=False)
 
 
 def _halfeven(s, r, p):
@@ -585,7 +585,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            with quotient C{div} an C{int} in Python 3+ or C{float}
            in Python 2- and remainder C{mod} an L{Fsum} instance.
 
-           @arg other: An L{Fsum}, L{Fsum2Tuple} or C{scalar} modulus.
+           @arg other: Modulus (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @kwarg raiser_RESIDUAL: Use C{B{raiser}=False} to ignore
                          L{ResidualError}s (C{bool}) and C{B{RESIDUAL}=scalar}
                          to override the current L{RESIDUAL<Fsum.RESIDUAL>}.
@@ -623,7 +623,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __floordiv__(self, other):
         '''Return C{B{self} // B{other}} as an L{Fsum}.
 
-           @arg other: An L{Fsum}, L{Fsum2Tuple} or C{scalar} divisor.
+           @arg other: Divisor (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
 
            @return: The C{floor} quotient (L{Fsum}).
 
@@ -632,6 +632,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         f = self._copyd(self.__floordiv__)
         return f._floordiv(other, _floordiv_op_)
 
+#   def __format__(self, *other):  # PYCHOK no cover
+#       '''Not implemented.'''
+#       return _NotImplemented(self, *other)
+
     def __ge__(self, other):
         '''Return C{(B{self} >= B{other})}, see C{__eq__}.
         '''
@@ -672,7 +676,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __ifloordiv__(self, other):
         '''Apply C{B{self} //= B{other}} to this instance.
 
-           @arg other: An L{Fsum}, L{Fsum2Tuple} or C{scalar} divisor.
+           @arg other: Divisor (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
 
            @return: This instance, updated (L{Fsum}).
 
@@ -696,7 +700,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __imod__(self, other):
         '''Apply C{B{self} %= B{other}} to this instance.
 
-           @arg other: An L{Fsum}, L{Fsum2Tuple} or C{scalar} modulus.
+           @arg other: Modulus (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
 
            @return: This instance, updated (L{Fsum}).
 
@@ -707,7 +711,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __imul__(self, other):
         '''Apply C{B{self} *= B{other}} to this instance.
 
-           @arg other: An L{Fsum}, L{Fsum2Tuple} or C{scalar} factor.
+           @arg other: Factor (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
 
            @return: This instance, updated (L{Fsum}).
 
@@ -736,7 +740,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __ipow__(self, other, *mod, **raiser_RESIDUAL):  # PYCHOK 2 vs 3 args
         '''Apply C{B{self} **= B{other}} to this instance.
 
-           @arg other: The exponent (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
+           @arg other: Exponent (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @arg mod: Optional modulus (C{int} or C{None}) for the 3-argument
                      C{pow(B{self}, B{other}, B{mod})} version.
            @kwarg raiser_RESIDUAL: Use C{B{raiser}=False} to ignore
@@ -798,7 +802,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __itruediv__(self, other, **raiser_RESIDUAL):
         '''Apply C{B{self} /= B{other}} to this instance.
 
-           @arg other: An L{Fsum}, L{Fsum2Tuple} or C{scalar} divisor.
+           @arg other: Divisor (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @kwarg raiser_RESIDUAL: Use C{B{raiser}=False} to ignore
                          L{ResidualError}s (C{bool}) and C{B{RESIDUAL}=scalar}
                          to override the current L{RESIDUAL<Fsum.RESIDUAL>}.
@@ -917,7 +921,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         f = self._rcopyd(other, self.__rfloordiv__)
         return f._floordiv(self, _floordiv_op_)
 
-    def __rmatmul__(self, other):  # PYCHOK no coveS
+    def __rmatmul__(self, other):  # PYCHOK no cover
         '''Not implemented.'''
         return _NotImplemented(self, other)
 
@@ -970,6 +974,11 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         f = self._rcopyd(other, self.__rtruediv__)
         return f._ftruediv(self, _truediv_op_, **raiser_RESIDUAL)
 
+#   def __sizeof__(self):
+#       '''Return the size of this instance (C{int} bytes}).
+#       '''
+#       return _sizeof(self._ps) + _sizeof(self._n)
+
     def __str__(self):
         '''Return the default C{str(self)}.
         '''
@@ -990,7 +999,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __truediv__(self, other, **raiser_RESIDUAL):
         '''Return C{B{self} / B{other}} as an L{Fsum}.
 
-           @arg other: An L{Fsum}, L{Fsum2Tuple} or C{scalar} divisor.
+           @arg other: Divisor (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @kwarg raiser_RESIDUAL: Use C{B{raiser}=False} to ignore
                          L{ResidualError}s (C{bool}) and C{B{RESIDUAL}=scalar}
                          to override the current L{RESIDUAL<Fsum.RESIDUAL>}.
@@ -1221,14 +1230,6 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         return self._facc_scalar(xs, **up)
 
-    def _facc_scalarf(self, xs, up=True, **origin_which):
-        '''(INTERNAL) Accumulate all C{xs}, each C{scalar}, an L{Fsum} or
-           L{Fsum2Tuple}, like function C{_xsum}.
-        '''
-        fs = _xs(xs, **_x_isfine(self.nonfinitesOK, _Cdot=type(self),
-                               **origin_which))  # PYCHOK yield
-        return self._facc_scalar(fs, up=up)
-
 #   def _facc_up(self, up=True):
 #       '''(INTERNAL) Update the C{partials}, by removing
 #          and re-accumulating the final C{partial}.
@@ -1243,6 +1244,14 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 #               break
 #       return self._update() if up else self
 
+    def _facc_xsum(self, xs, up=True, **origin_which):
+        '''(INTERNAL) Accumulate all C{xs}, each C{scalar}, an L{Fsum}
+           or L{Fsum2Tuple}, like function C{_xsum}.
+        '''
+        fs = _xs(xs, **_x_isfine(self.nonfinitesOK, _Cdot=type(self),
+                               **origin_which))  # PYCHOK yield
+        return self._facc_scalar(fs, up=up)
+
     def fadd(self, xs=()):
         '''Add an iterable's items to this instance.
 
@@ -1533,17 +1542,17 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def fover(self, over, **raiser_RESIDUAL):
         '''Apply C{B{self} /= B{over}} and summate.
 
-           @arg over: An L{Fsum} or C{scalar} denominator.
+           @arg over: Divisor (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @kwarg raiser_RESIDUAL: Use C{B{raiser}=False} to ignore
                          L{ResidualError}s (C{bool}) and C{B{RESIDUAL}=scalar}
                          to override the current L{RESIDUAL<Fsum.RESIDUAL>}.
 
-           @return: Precision running sum (C{float}).
+           @return: Precision running quotient sum (C{float}).
 
            @raise ResidualError: Non-zero, significant residual or invalid
                                  B{C{RESIDUAL}}.
 
-           @see: Methods L{Fsum.fsum} and L{Fsum.__itruediv__}.
+           @see: Methods L{Fsum.fdiv}, L{Fsum.__itruediv__} and L{Fsum.fsum}.
         '''
         return float(self.fdiv(over, **raiser_RESIDUAL)._fprs)
 
@@ -1837,19 +1846,19 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''Like method L{Fsum.fsum_} iff I{all} C{B{xs}}, each I{known to be}
            C{scalar}, an L{Fsum} or L{Fsum2Tuple}.
         '''
-        return self._facc_scalarf(xs, which=self.fsumf_)._fprs  # origin=1?
+        return self._facc_xsum(xs, which=self.fsumf_)._fprs  # origin=1?
 
     def Fsumf_(self, *xs):
         '''Like method L{Fsum.Fsum_} iff I{all} C{B{xs}}, each I{known to be}
            C{scalar}, an L{Fsum} or L{Fsum2Tuple}.
         '''
-        return self._facc_scalarf(xs, which=self.Fsumf_)._copyd(self.Fsumf_)  # origin=1?
+        return self._facc_xsum(xs, which=self.Fsumf_)._copyd(self.Fsumf_)  # origin=1?
 
     def fsum2f_(self, *xs):
         '''Like method L{Fsum.fsum2_} iff I{all} C{B{xs}}, each I{known to be}
            C{scalar}, an L{Fsum} or L{Fsum2Tuple}.
         '''
-        return self._fsum2(xs, self._facc_scalarf, which=self.fsum2f_)  # origin=1?
+        return self._fsum2(xs, self._facc_xsum, which=self.fsum2f_)  # origin=1?
 
 #   ftruediv = __itruediv__   # for naming consistency?
 

pygeodesy/gars.py

@@ -15,8 +15,7 @@ Transcoded from I{Charles Karney}'s C++ class U{GARS
 '''
 
 from pygeodesy.basics import isstr, _splituple,  typename
-from pygeodesy.constants import _off90, _1_over, _0_5, \
-                                _1_0  # PYCHOK used!
+from pygeodesy.constants import _off90, _1_over, _0_5
 from pygeodesy.errors import _ValueError, _xkwds, _xStrError
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _0to9_, _AtoZnoIO_, _INV_
@@ -30,7 +29,7 @@ from pygeodesy.units import Int_, Lat, Lon, Precision_, Scalar_, Str
 from math import floor
 
 __all__ = _ALL_LAZY.gars
-__version__ = '25.04.14'
+__version__ = '25.05.07'
 
 _Digits  = _0to9_
 _LatLen  =    2

pygeodesy/geodesici.py

@@ -23,7 +23,7 @@ and I{S. Baselga Moreno & J.C. Martinez-Llario}'s U{Intersection and point-to-li
 on the ellipsoid<https://riunet.UPV.ES/bitstream/handle/10251/122902/Revised_Manuscript.pdf>}.
 '''
 # make sure int/int division yields float quotient
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _copy, _enumereverse, map1, \
                              _xinstanceof, _xor,  typename
@@ -57,7 +57,7 @@ from pygeodesy.utily import atan2, sincos2,  fabs, radians
 # from math import ceil as _ceil, fabs, radians  # .fsums, .utily
 
 __all__ = _ALL_LAZY.geodesici
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 _0t     =  0,  # int
 _1_1t   = -1, +1
@@ -1560,7 +1560,7 @@ if __name__ == _DMAIN_:  # MCCABE 14
 
         _isopt = re.compile('^[-]+[a-z]*$', flags=re.IGNORECASE).match
 
-        I  =  Intersector(GeodesicExact())  # PYCHOK I
+        I  =  Intersector(GeodesicExact())  # noqa: E741 I is eye
         M  =  m = _R =  None
         _T = _V = _h = _C = False
 
@@ -1584,7 +1584,7 @@ if __name__ == _DMAIN_:  # MCCABE 14
             elif arg == _R__ and args:
                 _R = args.pop(0)
             elif _starts('--Tool', arg):
-                I = Intersectool()  # PYCHOK I
+                I = Intersectool()  # noqa: E741 I is eye
                 if _V:
                     I.verbose = True
                 if not _Xables.X_OK(I.IntersectTool):

pygeodesy/geodesicw.py

@@ -39,7 +39,7 @@ from contextlib import contextmanager
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.geodesicw
-__version__ = '25.04.14'
+__version__ = '25.05.28'
 
 _plumb_ = 'plumb'
 _TRIPS  =  65
@@ -96,6 +96,28 @@ class _gWrapped(_kWrapped):
                 if name:
                     self._name, _ = _name2__(name, _or_nameof=E)
 
+            def Area(self, polyline=False, **name):  # like GeodesicExact.Area
+                '''Return a C{PolygonArea} instance with method C{Compute} extended.
+                '''
+                _AreaBase = _wrapped._PolygonArea  # in .karney._kwrapped
+
+                class _PolygonArea(_AreaBase):
+                    # def __init__(self, *earth_polyline):
+                    #     _PolygonArea.__init__(self, *earth_polyline)
+
+                    def Compute(self, reverse=False, sign=True, polar=False):
+                        '''Use C{B{polar}=True} to adjust the area, see function
+                           L{areaOf<pygeodesy.geodesicx.gxarea.areaOf>}.
+                        '''
+                        n, p, a = _AreaBase.Compute(self, reverse=reverse, sign=sign)
+                        if polar:  # see .geodesicx.gxarea.GeodesicAreaExact._reduced
+                            a += _copysign(self.area0 * _0_5 * n, a)
+                        return n, p, a
+
+                A = _PolygonArea(self, polyline)
+                A.name = _name2__(name, _or_nameof=self)
+                return A
+
             def ArcDirect(self, lat1, lon1, azi1, a12, outmask=Caps.STANDARD):  # PYCHOK no cover
                 '''Return the C{_Geodesic.ArcDirect} result as L{GDict}.
                 '''
@@ -108,8 +130,6 @@ class _gWrapped(_kWrapped):
                 '''
                 return self._GenDirectLine(lat1, lon1, azi1, True, a12, caps, **name)
 
-            Area = _Geodesic.Polygon  # like GeodesicExact.Area
-
             @property_RO
             def datum(self):
                 '''Get this geodesic's datum (C{Datum}).
@@ -257,9 +277,8 @@ class _gWrapped(_kWrapped):
                 '''
                 return self._name
 
-#           Polygon = _Geodesic.Polygon
-
-            WGS84 = None  # _EWGS84.geodesicw recusion
+            Polygon = Area
+            WGS84   = None  # _EWGS84.geodesicw recusion
 
         # Geodesic.ArcDirect.__doc__   = _Geodesic.ArcDirect.__doc__
         # Geodesic.Direct.__doc__      = _Geodesic.Direct.__doc__
@@ -461,7 +480,7 @@ class Geodesic(_gWrapped):  # overwritten by 1st instance
            @kwarg name: Optional C{B{name}=NN} (C{str}).
         '''
         g = _wrapped.Geodesic(a_ellipsoid, f=f, **name)
-        _MODS.geodesicw.Geodesic = g.__class__  # overwrite class
+        _MODS.geodesicw.Geodesic = type(g)  # overwrite class
         return g
 
 
@@ -485,7 +504,7 @@ class GeodesicLine(_gWrapped):  # overwritten by 1st instance
            @kwarg name: Optional C{B{name}=NN} (C{str}).
         '''
         gl = _wrapped.GeodesicLine(geodesic, lat1, lon1, azi1, caps=caps, **name)
-        _MODS.geodesicw.GeodesicLine = gl.__class__  # overwrite class
+        _MODS.geodesicw.GeodesicLine = type(gl)  # overwrite class
         return gl
 
 

pygeodesy/geodesicx/__init__.py

@@ -17,13 +17,13 @@ respectively C{GeodesicLine} from I{Karney}'s Python implementation U{geographic
 L{pygeodesy.geodesicw} and L{pygeodesy.karney}.
 '''
 
-from pygeodesy.geodesicx.gx import GeodesicExact, GeodesicLineExact  # PYCHOK exported
-from pygeodesy.geodesicx.gxarea import GeodesicAreaExact, PolygonArea  # PYCHOK exported
+from pygeodesy.geodesicx.gx import GeodesicExact, GeodesicLineExact  # noqa: F401
+from pygeodesy.geodesicx.gxarea import GeodesicAreaExact, PolygonArea  # noqa: F401
 from pygeodesy.karney import Caps, GeodesicError
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 
 __all__ = _ALL_LAZY.geodesicx + _ALL_DOCS(Caps, GeodesicError)
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 # **) MIT License
 #

pygeodesy/geodesicx/gx.py

@@ -13,7 +13,7 @@ and licensed under the MIT/X11 License.  For more information, see the
 U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 '''
 # make sure int/int division yields float quotient
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 # A copy of comments from Karney's C{GeodesicExact.cpp}:
 #
@@ -44,11 +44,11 @@ from pygeodesy.constants import EPS, EPS0, EPS02, MANT_DIG, NAN, PI, _EPSqrt, \
 from pygeodesy.datums import _earth_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.errors import GeodesicError, _xkwds_pop2
-from pygeodesy.fmath import hypot as _hypot,  Fmt
+from pygeodesy.fmath import fdot_, hypot, hypot2,  Fmt
 from pygeodesy.fsums import fsumf_, fsum1f_
 from pygeodesy.geodesicx.gxbases import _cosSeries, _GeodesicBase, \
                                         _sincos12, _sin1cos2, _sinf1cos2d, \
-                                        _TINY, _xnC4
+                                        _TINY, _toNAN, _xnC4
 from pygeodesy.geodesicx.gxline import _GeodesicLineExact, _update_glXs
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _DOT_, _UNDER_
@@ -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.04.14'
+__version__ = '25.05.28'
 
 _MAXIT1 = 20
 _MAXIT2 = 10 + _MAXIT1 + MANT_DIG  # MANT_DIG == C++ digits
@@ -96,15 +96,12 @@ def _eTOL2(f):
     # (bet1 + bet2) / 2, the relative error in the azimuth
     # consistency check is sig12^2 * abs(f) * min(1, 1-f/2) / 2.
     # (Error measured for 1/100 < b/a < 100 and abs(f) >= 1/1000.
-
-    # For a given f and sig12, the max error occurs for lines
-    # near the pole.  If the old rule for computing dnm = (dn1
-    # + dn2)/2 is used, then the error increases by a factor of
-    # 2.)  Setting this equal to epsilon gives sig12 = etol2.
-
-    # Here 0.1 is a safety factor (error decreased by 100) and
-    # max(0.001, abs(f)) stops etol2 getting too large in the
-    # nearly spherical case.
+    #  For a given f and sig12, the max error occurs for lines
+    #  near the pole.  If the old rule for computing dnm = (dn1 +
+    #  dn2)/2 is used, then the error increases by a factor of 2.)
+    # Setting this equal to epsilon gives sig12 = eTOL2.  Here,
+    # safety factor 0.1 (error decreased by 100) and max(0.001, abs(f))
+    # stops eTOL2 getting too large in the nearly spherical case.
     t = min(_1_0, _1_0 - f * _0_5) * max(_0_001, fabs(f)) * _0_5
     return _TOL3 / (sqrt(t) if t > EPS02 else EPS0)
 
@@ -216,11 +213,10 @@ class GeodesicExact(_GeodesicBase):
         return GeodesicLineExact(self, lat1, lon1, azi1, caps=caps, **name)._GenSet(self._debug, a12=a12)
 
     def Area(self, polyline=False, **name):
-        '''Set up a L{GeodesicAreaExact} to compute area and
-           perimeter of a polygon.
+        '''Set up a L{GeodesicAreaExact} to compute area and perimeter of a polygon.
 
-           @kwarg polyline: If C{True}, compute the perimeter only, otherwise
-                            the perimeter and area (C{bool}).
+           @kwarg polyline: If C{True}, compute the perimeter only, otherwise the
+                            perimeter and area (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicAreaExact} instance.
@@ -429,17 +425,21 @@ class GeodesicExact(_GeodesicBase):
     def _eF_reset_cHe2_f1(self, x, y):
         '''(INTERNAL) Reset elliptic function and return M{cH * e2 / f1 * ...}.
         '''
-        self._eF_reset_k2(x)
-        return y * self._eF.cH * self._e2_f1
+        if isnan(x):
+            y = NAN
+        else:
+            self._eF_reset_k2(x)
+            y *= self._eF.cH * self._e2_f1
+        return y
 
     def _eF_reset_k2(self, x):
         '''(INTERNAL) Reset elliptic function and return C{k2}.
         '''
         ep2 = self.ep2
-        k2  = x**2 * ep2  # see .gxline._GeodesicLineExact._eF
-        self._eF.reset(k2=-k2, alpha2=-ep2)  # kp2, alphap2 defaults
+        x  *= x * ep2  # see .gxline._GeodesicLineExact._eF
+        self._eF.reset(k2=-x, alpha2=-ep2)  # kp2, alphap2 defaults
         _update_glXs(self)  # zap cached/memoized _GeodesicLineExact attrs
-        return k2
+        return x
 
     @Property_RO
     def ellipsoid(self):
@@ -499,6 +499,7 @@ class GeodesicExact(_GeodesicBase):
         if self._debug:  # PYCHOK no cover
             outmask |= Cs._DEBUG_INVERSE & self._debug
         outmask &= Cs._OUT_MASK  # incl. _SALP_CALPs_ and _DEBUG_
+        toNAN = _toNAN(outmask, lat1, lon1, lat2, 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
@@ -700,7 +701,9 @@ class GeodesicExact(_GeodesicBase):
                         eFk2=eF.k2, eFa2=eF.alpha2)
             p.update(r)  # r overrides p
             r = p.toGDict()
-        return self._iter2tion(r, **p)
+
+        r = self._iter2tion(r, **p)
+        return r._toNAN(outmask) if toNAN else r
 
     def _GenDirect(self, lat1, lon1, azi1, arcmode, s12_a12, outmask=Caps.STANDARD):
         '''(INTERNAL) The general I{Inverse} geodesic calculation.
@@ -805,8 +808,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>}.
         '''
-        Cs = Caps
-        r  = self._GDictInverse(lat1, lon1, lat2, lon2, caps | Cs._SALP_CALPs_)
+        r = self._GDictInverse(lat1, lon1, lat2, lon2, caps | Caps._SALP_CALPs_)
         return GeodesicLineExact(self, lat1, lon1, None, caps=caps, _s_calp1=(r.salp1, r.calp1),
                                                             **name)._GenSet(self._debug, **r)
 
@@ -839,12 +841,12 @@ class GeodesicExact(_GeodesicBase):
             #                   (tan(bet1/2) + tan(bet2/2)) /
             #                   (tan(bet1/2) * tan(bet2/2) + 1))
             # with tan(x/2) = sin(x) / (1 + cos(x))
-            dbet1  =  p.cbet1 + _1_0
-            dbet2  =  p.cbet2 + _1_0
-            domg12 =   comg12 + _1_0
-            salp12 = (p.sbet1 *   dbet2 + dbet1 * p.sbet2) * somg12
-            calp12 = (p.sbet1 * p.sbet2 + dbet1 *   dbet2) * domg12
-            alp12  =  atan2(salp12, calp12) * _2_0
+            dbet1  = p.cbet1 + _1_0
+            dbet2  = p.cbet2 + _1_0
+            domg12 =  comg12 + _1_0
+            salp12 = fdot_(p.sbet1,   dbet2, dbet1, p.sbet2) * somg12
+            calp12 = fdot_(p.sbet1, p.sbet2, dbet1,   dbet2) * domg12
+            alp12  = atan2(salp12, calp12) * _2_0
         else:
             # alp12 = alp2 - alp1, used in atan2, no need to normalize
             salp12, calp12 = _sincos12(salp1, calp1, salp2, calp2)
@@ -870,7 +872,7 @@ class GeodesicExact(_GeodesicBase):
                     and C{p.set_sigs} updated for Newton, C{sig12=None}.
         '''
         sig12 = None  # use Newton
-        salp1 = calp1 = salp2 = calp2 = dnm = NAN
+        salp1 = calp1 = salp2 = calp2 = NAN
 
         # bet12 = bet2 - bet1 in [0, PI)
         sbet12, cbet12 = _sincos12(p.sbet1, p.cbet1, p.sbet2, p.cbet2)
@@ -878,12 +880,15 @@ class GeodesicExact(_GeodesicBase):
         if shortline:
             # sin((bet1 + bet2)/2)^2 = (sbet1 + sbet2)^2 / (
             #      (cbet1 + cbet2)^2 + (sbet1 + sbet2)^2)
-            t = (p.sbet1 + p.sbet2)**2
-            s = t / ((p.cbet1 + p.cbet2)**2 + t)
-            dnm = sqrt(_1_0 + self.ep2 * s)
+            t = p.sbet1 + p.sbet2
+            if t:
+                t *= t / hypot2(t, p.cbet1 + p.cbet2)
+                dnm =  sqrt(self.ep2 * t + _1_0)
+            else:
+                dnm = _1_0
             somg12, comg12 = _sincos2(lam12 / (self.f1 * dnm))
         else:
-            somg12, comg12 = p.slam12, p.clam12
+            somg12, comg12, dnm = p.slam12, p.clam12, NAN
 
         # bet12a = bet2 + bet1 in (-PI, 0], note -sbet1
         sbet12a, cbet12a = _sincos12(-p.sbet1, p.cbet1, p.sbet2, p.cbet2)
@@ -894,8 +899,8 @@ class GeodesicExact(_GeodesicBase):
         salp1 =  p.cbet2 * somg12
         calp1 = (sbet12a - t) if comg12 < 0 else (sbet12 + t)
 
-        ssig12 = _hypot(salp1, calp1)
-        csig12 =  p.sbet1 * p.sbet2 + p.cbet1 * p.cbet2 * comg12
+        ssig12 = hypot(salp1, calp1)
+        csig12 = fdot_(p.sbet1, p.sbet2, p.cbet1, p.cbet2 * comg12)
 
         if shortline and ssig12 < self._eTOL2:  # really short lines
             t = c if comg12 < 0 else s
@@ -970,8 +975,8 @@ class GeodesicExact(_GeodesicBase):
                 #
                 # omg12 is near PI, estimate work with omg12a = PI - omg12
                 k    = _Astroid(x, y)
-                sca *= (y * (k + _1_0) / k) if f < 0 else \
-                       (x *  k / (k + _1_0))
+                k1   = _1_0 + k
+                sca *= (y * k1 / k) if f < 0 else (x * k / k1)
                 s, c = _sincos2(-sca)  # omg12a
                 # update spherical estimate of alp1 using omg12 instead of lam12
                 salp1 = p.cbet2 * s
@@ -1082,16 +1087,15 @@ class GeodesicExact(_GeodesicBase):
                 # Missing a factor of self.b.  Add parens around
                 # (csig1 * ssig2) and (ssig1 * csig2) to ensure
                 # accurate cancellation for coincident points.
-                m12b = fsum1f_(p.dn2 * (p.csig1 * p.ssig2),
-                              -p.dn1 * (p.ssig1 * p.csig2),
-                                 J12 * (p.csig1 * p.csig2))
+                m12b = fdot_(p.dn2, (p.csig1 * p.ssig2),
+                            -p.dn1, (p.ssig1 * p.csig2),
+                               J12, (p.csig1 * p.csig2))
             if (outmask & Cs.GEODESICSCALE):
-                M12 = M21 = p.ssig1 * p.ssig2 + \
-                            p.csig1 * p.csig2
+                M12 = M21 = fdot_(p.ssig1, p.ssig2, p.csig1, p.csig2)
                 t = (p.cbet1 - p.cbet2) * self.ep2 * \
                     (p.cbet1 + p.cbet2) / (p.dn1 + p.dn2)
-                M12 += (p.ssig2 * t + p.csig2 * J12) * p.ssig1 / p.dn1
-                M21 -= (p.ssig1 * t + p.csig1 * J12) * p.ssig2 / p.dn2
+                M12 += fdot_(p.ssig2, t, p.csig2, J12) * p.ssig1 / p.dn1
+                M21 -= fdot_(p.ssig1, t, p.csig1, J12) * p.ssig2 / p.dn2
 
         return s12b, m12b, m0, M12, M21
 
@@ -1310,7 +1314,7 @@ def _Astroid(x, y):
             u = _cbrt(S * _2_0)  # == T3 + _copysign(abs(S), T3)
         else:
             u = _0_0
-        v = _hypot(u, y)  # sqrt(u**2 + q)
+        v = hypot(u, y)  # sqrt(u**2 + q)
         # avoid loss of accuracy when u < 0
         u = (q / (v - u)) if u < 0 else (v + u)
         w = (u - q) / (v + v)  # positive?