pygeodesy 25.5.25__py2.py3-none-any.whl → 25.7.25__py2.py3-none-any.whl

pygeodesy/fmath.py

@@ -7,8 +7,8 @@ C{fused-multiply-add}, polynomials, roots, etc.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # noqa: E702 ;
 
-from pygeodesy.basics import _copysign, copysign0, isbool, isint, isscalar, \
-                              len2, map1, _xiterable,  typename
+from pygeodesy.basics import _copysign, copysign0, isbool, isint, isodd, \
+                              isscalar, len2, map1, _xiterable,  typename
 from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
                                _0_0, _0_125, _1_6th, _0_25, _1_3rd, _0_5, _1_0, \
                                _1_5, _copysign_0_0, isfinite, remainder
@@ -25,7 +25,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '25.05.12'
+__version__ = '25.06.03'
 
 # 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
@@ -66,7 +66,7 @@ class Fdot(Fsum):
         self._facc_dot(n, a, b, **kwds)
 
 
-class Fdot_(Fdot):
+class Fdot_(Fdot):  # in .elliptic
     '''Precision dot product.
     '''
     def __init__(self, *xys, **start_name_f2product_nonfinites_RESIDUAL):
@@ -78,6 +78,8 @@ class Fdot_(Fdot):
 
            @see: Class L{Fdot<Fdot.__init__>} for further details.
         '''
+        if isodd(len(xys)):
+            raise LenError(Fdot_, xys=len(xys))
         Fdot.__init__(self, xys[0::2], *xys[1::2], **start_name_f2product_nonfinites_RESIDUAL)
 
 

pygeodesy/frechet.py

@@ -101,7 +101,7 @@ from collections import defaultdict as _defaultdict
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.frechet
-__version__ = '25.05.21'
+__version__ = '25.05.26'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -153,7 +153,7 @@ class Frechet(_Named):
            @raise FrechetError: Insufficient number of B{C{point1s}} or an invalid
                                 B{C{point1}}, B{C{fraction}} or B{C{units}}.
         '''
-        name, kwds = _name2__(**name__kwds)  # name__=self.__class__
+        name, kwds = _name2__(**name__kwds)  # name__=type(self)
         if name:
             self.name = name
 

pygeodesy/fsums.py

@@ -39,15 +39,13 @@ 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 _  # noqa: E702 ;
 
-from pygeodesy.basics import _gcd, isbool, iscomplex, isint, isscalar, \
+from pygeodesy.basics import _gcd, isbool, iscomplex, isint, isodd, isscalar, \
                              _signOf, itemsorted, signOf, _xiterable
-from pygeodesy.constants import INF, INT0, MANT_DIG, NEG0, NINF, _0_0, \
-                               _1_0, _N_1_0, _isfinite, _pos_self, \
-                               Float, Int
-from pygeodesy.errors import _AssertionError, _OverflowError, _TypeError, \
-                             _ValueError, _xError, _xError2, _xkwds, \
-                             _xkwds_get, _xkwds_get1, _xkwds_not, \
-                             _xkwds_pop, _xsError
+from pygeodesy.constants import INF, INT0, MANT_DIG, NEG0, NINF, _0_0, _1_0, \
+                               _N_1_0, _isfinite, _pos_self,  Float, Int
+from pygeodesy.errors import _AssertionError, _OverflowError, LenError, _TypeError, \
+                             _ValueError, _xError, _xError2, _xkwds, _xkwds_get, \
+                             _xkwds_get1, _xkwds_not, _xkwds_pop, _xsError
 from pygeodesy.internals import _enquote, _envPYGEODESY, _passarg, typename  # _sizeof
 from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DMAIN_, _DOT_, _from_, \
                              _not_finite_, _SPACE_, _std_, _UNDER_
@@ -64,7 +62,7 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '25.05.12'
+__version__ = '25.06.03'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -121,7 +119,9 @@ try:  # MCCABE 26
             f = x * y
             yield f
             if _isfinite(f):
-                yield _fma(x, y, -f)
+                f = _fma(x, y, -f)
+                if f:
+                    yield f
         for z in zs:
             yield z
 
@@ -162,7 +162,7 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
     def _fmaX(r, *a_b_c):  # PYCHOK no cover
         # handle non-finite fma result as Python 3.13+ C-function U{math_fma_impl
         # <https://GitHub.com/python/cpython/blob/main/Modules/mathmodule.c#L2305>}:
-        # raise a ValueError for a NAN result from non-NAN C{a_b_c}s otherwise an
+        # raise a ValueError for a NAN result from non-NAN C{a_b_c}s, otherwise an
         # OverflowError for a non-finite, non-NAN result from all finite C{a_b_c}s.
         if isnan(r):
             def _x(x):
@@ -560,7 +560,6 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         self._fset(other, op=_fset_op_, **up)
         return self
 
-
     def __ceil__(self):  # PYCHOK not special in Python 2-
         '''Return this instance' C{math.ceil} as C{int} or C{float}.
 
@@ -1137,7 +1136,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         return E(u, txt=t, cause=X)
 
     def _facc(self, xs, up=True, **_X_x_origin):
-        '''(INTERNAL) Accumulate more C{scalar}s or L{Fsum}s.
+        '''(INTERNAL) Accumulate more C{scalar}s, L{Fsum}s pr L{Fsum2Tuple}s.
         '''
         if xs:
             kwds = self._isfine
@@ -1472,6 +1471,29 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             f  = self._nonfiniteX(X, op, f, **nonfinites)
         return self._fset(f)
 
+    def fma_(self, *xys, **nonfinites):
+        '''Fused-multiply-accumulate C{for i in range(0, len(xys), B{2}):
+           self = }L{fma<pygeodesy.fmath.fma>}C{(xys[i], xys[i+1], self)}.
+
+           @arg xys: Pairwise multiplicand, multiplier (each C{scalar},
+                     an L{Fsum} or L{Fsum2Tuple}), all positional.
+           @kwarg nonfinites: Use C{B{nonfinites}=True} or C{False}, to
+                              override L{nonfinites<Fsum.nonfinites>} and
+                              L{nonfiniterrors} default (C{bool}).
+
+           @note: Equivalent to L{fdot_<pygeodesy.fmath.fdot_>}C{(*xys,
+                  start=self)}.
+        '''
+        if xys:
+            n = len(xys)
+            if n < 2 or isodd(n):
+                raise LenError(self.fma_, xys=n)
+            f, _fmath_fma = self, _MODS.fmath.fma
+            for x, y in zip(xys[0::2], xys[1::2]):
+                f = _fmath_fma(x, y, f, **nonfinites)
+            self._fset(f)
+        return self
+
     fmul = __imul__
 
     def _fmul(self, other, op):
@@ -1581,8 +1603,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            L{Fsum}, overriding the L{f2product} default.
 
            @arg two: If omitted, leave the override unchanged, if C{True},
-                     turn I{TwoProduct} on, if C{False} off, if C{None}e
-                     remove th override (C{bool} or C{None}).
+                     turn I{TwoProduct} on, if C{False} off, or if C{None}
+                     remove the override (C{bool} or C{None}).
 
            @return: The previous setting (C{bool} or C{None} if not set).
 
@@ -2682,11 +2704,11 @@ try:
         del _fsum  # nope, remove _fsum ...
         raise ImportError()  # ... use _fsum below
 
-    _sum = _fsum  # in .elliptic
+    _sum = _fsum
 except ImportError:
-    _sum =  sum  # in .elliptic
+    _sum =  sum
 
-    def _fsum(xs):
+    def _fsum(xs):  # in .elliptic
         '''(INTERNAL) Precision summation, Python 2.5-.
         '''
         F = Fsum(name=_fsum.name, f2product=False, nonfinites=True)

pygeodesy/geodesici.py

@@ -29,8 +29,8 @@ from pygeodesy.basics import _copy, _enumereverse, map1, \
                              _xinstanceof, _xor,  typename
 from pygeodesy.constants import EPS, INF, INT0, PI, PI2, PI_4, \
                                _0_0, _0_5, _1_0, _1_5, _2_0, _3_0, \
-                               _45_0, _64_0, _90_0, isfinite, \
-                               _EPSjam  # PYCHOK used!
+                               _45_0, _64_0, _90_0, isfinite
+from pygeodesy.constants import _EPSjam  # PYCHOK used!
 from pygeodesy.ellipsoids import _EWGS84,  Fmt, unstr
 from pygeodesy.errors import GeodesicError, IntersectionError, _an, \
                             _xgeodesics, _xkwds_get, _xkwds_kwds, \
@@ -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.05.12'
+__version__ = '25.06.02'
 
 _0t     =  0,  # int
 _1_1t   = -1, +1

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

@@ -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.05.12'
+__version__ = '25.06.04'
 
 # **) MIT License
 #

pygeodesy/geodesicx/__main__.py

@@ -5,7 +5,7 @@ u'''Print L{geodesicx} version, etc. using C{python -m pygeodesy.geodesicx}.
 '''
 
 __all__ = ()
-__version__ = '25.04.14'
+__version__ = '25.06.01'
 
 
 def _main(**C4order):  # PYCHOK no cover
@@ -47,7 +47,7 @@ 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.04.14: C4order=30, C4n=5425, C4u=5107, C4u_n=94.1%, C4x=465, C4t=tuple, C4z=166008, geographiclib 2.0 (pygeodesy 25.4.24 Python 3.13.3 64bit arm64 macOS 15.4)
+# 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)
 
 # % python3.13 -m pygeodesy.geodesicx 30
 # pygeodesy.geodesicx 24.09.06: C4order=30, C4n=5425, C4u=5107, C4u_n=94.1%, C4x=465, C4t=tuple, C4z=166008 (pygeodesy 24.9.6 Python 3.13.0rc1 64bit arm64 macOS 14.6.1)

pygeodesy/geodesicx/gx.py

@@ -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.05.12'
+__version__ = '25.06.01'
 
 _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
 
@@ -1223,7 +1227,8 @@ class GeodesicExact(_GeodesicBase):
             tripb = fsum1f_(calp1a, -calp1, _abs(salp1a - salp1)) < TOLb or \
                     fsum1f_(calp1b, -calp1, _abs(salp1b - salp1)) < TOLb
         else:
-            raise GeodesicError(Fmt.no_convergence(v, TOLv), txt=repr(self))  # self.toRepr()
+            v = Fmt.no_convergence(v, TOLv)
+            raise GeodesicError(v, txt=repr(self))  # self.toRepr()
 
         p.set_(iter=i, trip=tripb)  # like .geodsolve._GDictInvoke: iter NOT iteration!
         return sig12, salp1, calp1, salp2, calp2, domg12
@@ -1310,7 +1315,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?