pygeodesy 24.10.10__py2.py3-none-any.whl → 24.11.11__py2.py3-none-any.whl

pygeodesy/etm.py

@@ -11,7 +11,7 @@ Class L{ExactTransverseMercator} provides C{Exact Transverse Mercator} projectio
 instances of class L{Etm} represent ETM C{(easting, northing)} locations.  See also
 I{Karney}'s utility U{TransverseMercatorProj<https://GeographicLib.SourceForge.io/C++/doc/
 TransverseMercatorProj.1.html>} and use C{"python[3] -m pygeodesy.etm ..."} to compare
-the results.
+the results, see usage C{"python[3] -m pygeodesy.etm -h"}.
 
 Following is a copy of I{Karney}'s U{TransverseMercatorExact.hpp
 <https://GeographicLib.SourceForge.io/C++/doc/TransverseMercatorExact_8hpp_source.html>}
@@ -65,23 +65,25 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import map1, neg, neg_, _xinstanceof
 from pygeodesy.constants import EPS, EPS02, PI_2, PI_4, _K0_UTM, \
-                               _1_EPS, _0_0, _0_1, _0_5, _1_0, _2_0, \
-                               _3_0, _4_0, _90_0, isnear0, isnear90
+                             _1_EPS, _0_0, _0_1, _0_5, _1_0, _2_0, \
+                             _3_0, _90_0, isnear0, isnear90
+from pygeodesy.constants import _4_0  # PYCHOK used!
 from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
-from pygeodesy.elliptic import _ALL_LAZY, Elliptic
+# from pygeodesy.elliptic import Elliptic  # _MODS
 # from pygeodesy.errors import _incompatible  # from .named
 # from pygeodesy.fsums import Fsum  # from .fmath
 from pygeodesy.fmath import cbrt, hypot, hypot1, hypot2,  Fsum
 from pygeodesy.interns import _COMMASPACE_, _near_, _SPACE_, _spherical_
 from pygeodesy.karney import _K_2_4, _copyBit, _diff182, _fix90, \
                              _norm2, _norm180, _tand, _unsigned2
-# from pygeodesy.lazily import _ALL_LAZY  # from .elliptic
-from pygeodesy.named import callername, _incompatible, _NamedBase
+# from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
+from pygeodesy.named import callername, _incompatible, _NamedBase, \
+                           _ALL_LAZY, _MODS
 from pygeodesy.namedTuples import Forward4Tuple, Reverse4Tuple
 from pygeodesy.props import deprecated_method, deprecated_property_RO, \
                             Property_RO, property_RO, _update_all, \
-                            property_doc_
+                            property_doc_,  _allPropertiesOf_n
 from pygeodesy.streprs import Fmt, pairs, unstr
 from pygeodesy.units import Degrees, Scalar_
 from pygeodesy.utily import atan1d, atan2d, _loneg, sincos2
@@ -91,12 +93,12 @@ from pygeodesy.utm import _cmlon, _LLEB, _parseUTM5, _toBand, _toXtm8, \
 from math import asinh, atan2, degrees, radians, sinh, sqrt
 
 __all__ = _ALL_LAZY.etm
-__version__ = '24.09.06'
+__version__ = '24.11.04'
 
-_OVERFLOW = _1_EPS**2  # about 2e+31
-_TAYTOL   =  pow(EPS, 0.6)
+_OVERFLOW = _1_EPS**2  # ~2e+31
+_TAYTOL   =  pow(EPS,  0.6)
 _TAYTOL2  = _TAYTOL * _2_0
-_TOL_10   =  EPS * _0_1
+_TOL_10   =  EPS    * _0_1
 _TRIPS    =  21  # C++ 10
 
 
@@ -218,12 +220,12 @@ class Etm(Utm):
 class ExactTransverseMercator(_NamedBase):
     '''Pure Python version of Karney's C++ class U{TransverseMercatorExact
        <https://GeographicLib.SourceForge.io/C++/doc/TransverseMercatorExact_8cpp_source.html>},
-       a numerically exact transverse Mercator projection, further referred to as C{TMExact}.
+       a numerically exact transverse Mercator projection, abbreviated as C{TMExact}.
     '''
     _datum     = _WGS84       # Datum
     _E         = _EWGS84      # Ellipsoid
     _extendp   =  False       # use extended domain
-#   _iteration =  None        # ._sigmaInv2 and ._zetaInv2
+#   _iteration =  None        # _NameBase, ._sigmaInv2 and ._zetaInv2
     _k0        = _K0_UTM      # central scale factor
     _lat0      = _0_0         # central parallel
     _lon0      = _0_0         # central meridian
@@ -240,7 +242,7 @@ class ExactTransverseMercator(_NamedBase):
                          L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}).
            @kwarg lon0: Central meridian, default (C{degrees180}).
            @kwarg k0: Central scale factor (C{float}).
-           @kwarg extendp: Use the I{extended} domain (C{bool}), I{standard} otherwise.
+           @kwarg extendp: If C{True}, use the I{extended} domain, I{standard} otherwise (C{bool}).
            @kwarg raiser: If C{True}, throw an L{ETMError} for convergence failures (C{bool}).
            @kwarg name: Optional C{B{name}=NN} for the projection (C{str}).
 
@@ -349,7 +351,7 @@ class ExactTransverseMercator(_NamedBase):
     def _Eu(self):
         '''(INTERNAL) Get and cache C{Elliptic(_mu)}.
         '''
-        return Elliptic(self._mu)
+        return _MODS.elliptic.Elliptic(self._mu)
 
     @Property_RO
     def _Eu_cE(self):
@@ -390,7 +392,7 @@ class ExactTransverseMercator(_NamedBase):
     def _Ev(self):
         '''(INTERNAL) Get and cache C{Elliptic(_mv)}.
         '''
-        return Elliptic(self._mv)
+        return _MODS.elliptic.Elliptic(self._mv)
 
     @Property_RO
     def _Ev_cK(self):
@@ -416,7 +418,7 @@ class ExactTransverseMercator(_NamedBase):
         '''
         return self._Ev_cKE * 1.25  # _1_25
 
-    @Property_RO
+    @property_RO
     def extendp(self):
         '''Get the domain (C{bool}), I{extended} or I{standard}.
         '''
@@ -635,7 +637,7 @@ class ExactTransverseMercator(_NamedBase):
         '''Set the central parallel and meridian.
 
            @arg lat0: Latitude of the central parallel (C{degrees90}).
-           @arg lon0: Longitude of the central parallel (C{degrees180}).
+           @arg lon0: Longitude of the central meridian (C{degrees180}).
 
            @return: 2-Tuple C{(lat0, lon0)} of the previous central
                     parallel and meridian.
@@ -644,7 +646,7 @@ class ExactTransverseMercator(_NamedBase):
         '''
         t = self._lat0, self.lon0
         self._lat0 = _fix90(Degrees(lat0=lat0, Error=ETMError))
-        self. lon0 =  lon0
+        self. lon0 =  lon0  # lon0.setter
         return t
 
     def _resets(self, datum):
@@ -655,15 +657,15 @@ class ExactTransverseMercator(_NamedBase):
            @raise ETMError: Near-spherical B{C{datum}} or C{ellipsoid}.
         '''
         E  = datum.ellipsoid
-        mu = E.e2   # .eccentricity1st2
+        mu = E.e2   # E.eccentricity1st2
         mv = E.e21  # _1_0 - mu
         if isnear0(E.e) or isnear0(mu, eps0=EPS02) \
                         or isnear0(mv, eps0=EPS02):  # or sqrt(mu) != E.e
             raise ETMError(ellipsoid=E, txt=_near_(_spherical_))
 
         if self._datum or self._E:
-            _i = ExactTransverseMercator.iteration._uname
-            _update_all(self, _i, '_sigmaC', '_zetaC')  # _under
+            _i = ExactTransverseMercator.iteration._uname  # property_RO
+            _update_all(self, _i, '_sigmaC', '_zetaC', Base=Property_RO)  # _under
 
         self._E  = E
         self._mu = mu
@@ -757,7 +759,7 @@ class ExactTransverseMercator(_NamedBase):
             # k = sqrt(mv + mu / sec2) * sqrt(sec2) * sqrt(q2)
             #   = sqrt(mv * sec2 + mu) * sqrt(q2)
             #   = sqrt(mv + mv * tau**2 + mu) * sqrt(q2)
-            k, q2 = _0_0, (mv * snv**2 + cnudnv**2)
+            k, q2 = _0_0, (snv**2 * mv + cnudnv**2)
             if q2 > 0:
                 k2 = (tau**2 + _1_0) * mv + mu
                 if k2 > 0:
@@ -809,9 +811,9 @@ class ExactTransverseMercator(_NamedBase):
         d = (cnv**2 + snuv**2 * mu)**2 * self._mv
         r =  cnv * dnu * dnv
         i =  cnu * snuv * mu
-        du = (r**2 - i**2) / d  # (r + i) * (r - i) / d
-        dv = neg(r * i * _2_0 / d)
-        return du, dv
+        du = (r + i) * (r - i) / d  # (r**2 - i**2) / d
+        dv =  r * i * _2_0 / d
+        return du, neg(dv)
 
     def _sigmaInv2(self, xi, eta):
         '''(INTERNAL) Invert C{sigma} using Newton's method.
@@ -874,7 +876,8 @@ class ExactTransverseMercator(_NamedBase):
         '''
         # snu, cnu, dnu = self._Eu.sncndn(u)
         # snv, cnv, dnv = self._Ev.sncndn(v)
-        return self._Eu.sncndn(u, **jam) + self._Ev.sncndn(v, **jam)
+        return self._Eu.sncndn(u, **jam) + \
+               self._Ev.sncndn(v, **jam)
 
     def toStr(self, joined=_COMMASPACE_, **kwds):  # PYCHOK signature
         '''Return a C{str} representation.
@@ -900,21 +903,19 @@ class ExactTransverseMercator(_NamedBase):
                                       real &taup, real &lam)}
         '''
         e, cnu2, mv = self._e, cnu**2, self._mv
-        # Overflow value like atan(overflow) = pi/2
-        t1 = t2 = _overflow(snu)
         # Lee 54.17 but write
         # atanh(snu * dnv)      = asinh(snu * dnv / sqrt(cnu^2 + _mv * snu^2 * snv^2))
         # atanh(_e * snu / dnv) = asinh(_e * snu / sqrt(_mu * cnu^2 + _mv * cnv^2))
-        d1 = cnu2 + mv * (snu * snv)**2
+        d1 = cnu2 + (snu * snv)**2 * mv
         if d1 > EPS02:  # _EPSmin
             t1 = snu * dnv / sqrt(d1)
-        else:
-            d1 = 0
-        d2 = self._mu * cnu2 + mv * cnv**2
+        else:  # like atan(overflow) = pi/2
+            t1, d1 = _overflow(snu), 0
+        d2 = cnu2 * self._mu + cnv**2 * mv
         if d2 > EPS02:  # _EPSmin
             t2 = sinh(e * asinh(e * snu / sqrt(d2)))
         else:
-            d2 = 0
+            t2, d2 = _overflow(snu), 0
         # psi = asinh(t1) - asinh(t2)
         # taup = sinh(psi)
         taup = t1 * hypot1(t2) - t2 * hypot1(t1)
@@ -939,9 +940,9 @@ class ExactTransverseMercator(_NamedBase):
         snuv2 = snuv**2 * self._mu
         # Lee 54.21 but write (see A+S 16.21.4)
         # (1 - dnu^2 * snv^2) = (cnv^2 + _mu * snu^2 * snv^2)
-        d  = self._mv   * (cnv2 + snuv2)**2  # max(d, EPS02)?
-        du = cnu * dnuv * (cnv2 - snuv2) / d
-        dv = cnv * snuv * (cnu2 + dnuv2) / d
+        d  = (cnv2 + snuv2)**2    * self._mv  # max(d, EPS02)?
+        du = (cnv2 - snuv2) * cnu * dnuv / d
+        dv = (cnu2 + dnuv2) * cnv * snuv / d
         return du, neg(dv)
 
     def _zetaInv2(self, taup, lam):
@@ -1021,6 +1022,9 @@ class ExactTransverseMercator(_NamedBase):
             g_k += atan1d(tau), degrees(lam)
         return g_k  # or (g, k, lat, lon)
 
+_allPropertiesOf_n(22, ExactTransverseMercator, Property_RO)  # PYCHOK assert
+del _0_1, _allPropertiesOf_n, EPS, _1_EPS, _EWGS84
+
 
 def _overflow(x):
     '''(INTERNAL) Like C{copysign0(OVERFLOW, B{x})}.
@@ -1102,32 +1106,42 @@ if __name__ == '__main__':  # MCCABE 16
     def _main():
 
         from pygeodesy import fstr, KTransverseMercator
-#       from pygeodesy.interns import _DASH_  # from internals
-        from pygeodesy.internals import printf, _usage,  _DASH_
+        from pygeodesy.interns import _BAR_, _COLONSPACE_, _DASH_, NN
+        from pygeodesy.internals import printf, _usage
         from sys import argv, exit as _exit
 
-        def _help():
-            _exit(_usage(argv[0], '[-s | -t ]',
-                                  '[-p[recision] <ndigits>',
-                                  '[-f[orward] <lat> <lon>',
-                                  '|-r[everse] <easting> <northing>',
-                                  '|<lat> <lon>]',
-                                  '|-h[elp]'))
+        def _error(why, _a=NN):
+            if _a:
+                why = 'option %r %s' % (_a, why)
+            _exit(_COLONSPACE_(_usage(*argv), why))
+
+        def _help(*why):
+            if why:
+                printf(_COLONSPACE_(_usage(*argv), *why))
+            _exit(_usage(argv[0], '[-s[eries]', _BAR_, '-t]',
+                                  '[-p[recision] <ndigits>]',
+                                  '[-f[orward] <lat> <lon>', _BAR_,
+                                  '-r[everse] <easting> <northing>', _BAR_,
+                                  '<lat> <lon>]', _BAR_,
+                                  '-h[elp]'))
+
+        def _result(t4):
+            printf(_COLONSPACE_(tm.classname, fstr(t4, prec=_p, sep=_SPACE_)))
 
         # mimick some of I{Karney}'s utility C{TransverseMercatorProj}
         _f = _r = _s = _t = False
         _p = -6
-        _as = argv[1:]
-        while _as and _as[0].startswith(_DASH_):
-            _a = _as.pop(0)
+        args = argv[1:]
+        while args and args[0].startswith(_DASH_):
+            _a = args.pop(0)
             if len(_a) < 2:
-                _exit('%s: option %r invalid' % (_usage(*argv), _a))
+                _error('invalid', _a)
             elif '-forward'.startswith(_a):
                 _f, _r = True, False
             elif '-reverse'.startswith(_a):
                 _f, _r = False, True
-            elif '-precision'.startswith(_a):
-                _p = int(_as.pop(0))
+            elif '-precision'.startswith(_a) and args:
+                _p = int(args.pop(0))
             elif '-series'.startswith(_a):
                 _s, _t = True, False
             elif _a == '-t':
@@ -1135,39 +1149,49 @@ if __name__ == '__main__':  # MCCABE 16
             elif '-help'.startswith(_a):
                 _help()
             else:
-                _exit('%s: option %r not supported' % (_usage(*argv), _a))
-
-        if len(_as) > 1:
-            f2 = map1(float, *_as[:2])
-        else:
-            printf('%s ...: incomplete', _usage(*argv))
-            _help()
-
-        if _s:  # -series
-            tm = KTransverseMercator()
-        else:
-            tm = ExactTransverseMercator(extendp=_t)
+                _error('not supported', _a)
+        if len(args) < 2:
+            _help('incomplete')
 
+        f2 = map1(float, *args[:2])
+        tm = KTransverseMercator() if _s else \
+             ExactTransverseMercator(extendp=_t)
         if _f:
             t = tm.forward(*f2)
         elif _r:
             t = tm.reverse(*f2)
         else:
             t = tm.forward(*f2)
-            printf('%s: %s', tm.classname, fstr(t, prec=_p, sep=_SPACE_))
+            _result(t)
             t = tm.reverse(t.easting, t.northing)
-        printf('%s: %s', tm.classname, fstr(t, prec=_p, sep=_SPACE_))
+        _result(t)
 
     _main()
 
-# % python3.12 -m pygeodesy.etm -p 12 33.33 44.44
+# % python3.13 -m pygeodesy.etm -p 12  33.33 44.44
+# ExactTransverseMercator: 4276926.114803905599 4727193.767015309073 28.375536563148 1.233325101778
+# ExactTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
+
+# % python3.13 -m pygeodesy.etm -s  -p 12  33.33 44.44
+# KTransverseMercator: 4276926.114803904667 4727193.767015310004 28.375536563148 1.233325101778
+# KTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
+
+# % python3.12 -m pygeodesy.etm -p 12  33.33 44.44
 # ExactTransverseMercator: 4276926.11480390653 4727193.767015309073 28.375536563148 1.233325101778
 # ExactTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
 
-# % python3.12 -s -m pygeodesy.etm -p 12 33.33 44.44
+# % python3.12 -m pygeodesy.etm -s  -p 12  33.33 44.44
+# KTransverseMercator: 4276926.114803904667 4727193.767015310004 28.375536563148 1.233325101778
+# KTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
+
+# % python2 -m pygeodesy.etm -p 12  33.33 44.44
 # ExactTransverseMercator: 4276926.11480390653 4727193.767015309073 28.375536563148 1.233325101778
 # ExactTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
 
+# % python2 -m pygeodesy.etm -s  -p 12  33.33 44.44
+# KTransverseMercator: 4276926.114803904667 4727193.767015310004 28.375536563148 1.233325101778
+# KTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
+
 # % echo 33.33 44.44 | .../bin/TransverseMercatorProj
 # 4276926.114804 4727193.767015 28.375536563148 1.233325101778
 

pygeodesy/fmath.py

@@ -12,11 +12,10 @@ 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
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
-                             _xError, _xkwds_pop2, _xsError
-from pygeodesy.fsums import _2float, Fsum, fsum, _isFsum_2Tuple, _1primed, \
-                             Fmt, unstr
+                             _xError, _xkwds, _xkwds_pop2, _xsError
+from pygeodesy.fsums import _2float, Fsum, fsum, _isFsum_2Tuple,  Fmt, unstr
 from pygeodesy.interns import MISSING, _negative_, _not_scalar_
-from pygeodesy.lazily import _ALL_LAZY, _sys_version_info2
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
 from pygeodesy.units import Int_, _isHeight, _isRadius,  Float_  # PYCHOK for .heights
 
@@ -24,7 +23,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '24.10.04'
+__version__ = '24.11.08'
 
 # sqrt(2) - 1 <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ... ~ 3730904090310553 / 9007199254740992
@@ -62,14 +61,7 @@ class Fdot(Fsum):
         n = len(b)
         if len(a) != n:  # PYCHOK no cover
             raise LenError(Fdot, a=len(a), b=n)
-        self._faddot(n, a, b, **kwds)
-
-    def _faddot(self, n, xs, ys, **kwds):
-        if n > 0:
-            _f = Fsum(**kwds)
-            r = (_f(x).fmul(y) for x, y in zip(xs, ys))  # PYCHOK attr?
-            self.fadd(_1primed(r) if n < 4 else r)  # PYCHOK attr?
-        return self
+        self._facc_dot(n, a, b, **kwds)
 
 
 class Fhorner(Fsum):
@@ -129,7 +121,7 @@ class Fhypot(Fsum):
             raise self._ErrorXs(X, xs, root=r)
 
 
-class Fpolynomial(Fdot):
+class Fpolynomial(Fsum):
     '''Precision polynomial evaluation.
     '''
     def __init__(self, x, *cs, **name_f2product_nonfinites_RESIDUAL):
@@ -150,12 +142,10 @@ class Fpolynomial(Fdot):
 
            @see: Class L{Fhorner}, function L{fpolynomial} and method L{Fsum.fadd}.
         '''
-        Fsum.__init__(self, *cs[:1], **name_f2product_nonfinites_RESIDUAL)
+        Fsum.__init__(self, **name_f2product_nonfinites_RESIDUAL)
         n = len(cs) - 1
-        if n > 0:
-            self._faddot(n, cs[1:], _powers(x, n), **name_f2product_nonfinites_RESIDUAL)
-        elif n < 0:
-            self(_0_0)
+        self(_0_0 if n < 0 else cs[0])
+        self._facc_dot(n, cs[1:], _powers(x, n), **name_f2product_nonfinites_RESIDUAL)
 
 
 class Fpowers(Fsum):
@@ -431,35 +421,48 @@ def favg(a, b, f=_0_5, nonfinites=True):
     return float(F)
 
 
-def fdot(a, *b, **start):
-    '''Return the precision dot product M{sum(a[i] * b[i] for ni=0..len(a))}.
+def fdot(xs, *ys, **start_f2product_nonfinites):
+    '''Return the precision dot product M{sum(xs[i] * ys[i] for i in range(len(xs)))}.
 
-       @arg a: Iterable of values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
-       @arg b: Other values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}), all
+       @arg xs: Iterable of values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
+       @arg ys: Other values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}), all
                positional.
-       @kwarg start: Optional bias C{B{start}=0} (C{scalar}, an L{Fsum} or
-                     L{Fsum2Tuple}).
+       @kwarg start_f2product_nonfinites: Optional bias C{B{start}=0} (C{scalar}, an
+                    L{Fsum} or L{Fsum2Tuple}) and settings C{B{f2product}=None} (C{bool})
+                    and C{B{nonfinites=True}} (C{bool}), see class L{Fsum<Fsum.__init__>}.
 
        @return: Dot product (C{float}).
 
-       @raise LenError: Unequal C{len(B{a})} and C{len(B{b})}.
+       @raise LenError: Unequal C{len(B{xs})} and C{len(B{ys})}.
 
        @see: Class L{Fdot}, U{Algorithm 5.10 B{DotK}
              <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>} and function
              C{math.sumprod} in Python 3.12 and later.
     '''
-    D = Fdot(a, nonfinites=True, *b, **start)
+    D = Fdot(xs, *ys, **_xkwds(start_f2product_nonfinites, nonfinites=True))
     return float(D)
 
 
-def fdot3(xs, ys, zs, start=0):
-    '''Return the precision dot product M{start + sum(a[i] * b[i] * c[i]
-       for i=0..len(a)-1)}.
+def fdot_(*xys, **start_f2product_nonfinites):
+    '''Return the (precision) dot product M{sum(xys[i] * xys[i+1] for i in range(0, len(xys), B{2}))}.
+
+       @arg xys: Pairwise values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}), all positional.
+
+       @see: Function L{fdot} for further details.
+
+       @return: Dot product (C{float}).
+    '''
+    return fdot(xys[0::2], *xys[1::2], **start_f2product_nonfinites)
+
+
+def fdot3(xs, ys, zs, **start_f2product_nonfinites):
+    '''Return the (precision) dot product M{start + sum(xs[i] * ys[i] * zs[i] for i in range(len(xs)))}.
 
        @arg xs: Iterable (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
        @arg ys: Iterable (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
        @arg zs: Iterable (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
-       @kwarg start: Optional bias (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
+
+       @see: Function L{fdot} for further details.
 
        @return: Dot product (C{float}).
 
@@ -469,17 +472,16 @@ def fdot3(xs, ys, zs, start=0):
     if not n == len(ys) == len(zs):
         raise LenError(fdot3, xs=n, ys=len(ys), zs=len(zs))
 
-    D  = Fdot((), nonfinites=True, start=start)
-    _f = Fsum(nonfinites=True)  # f2product=True
-    r  = (_f(x).f2mul_(y, z) for x, y, z in zip(xs, ys, zs))
-    D  = D.fadd(_1primed(r) if n < 4 else r)
+    D  = Fdot((), **_xkwds(start_f2product_nonfinites, nonfinites=True))
+    kwds = dict(f2product=D.f2product(), nonfinites=D.nonfinites())
+    _f = Fsum(**kwds)
+    D  = D._facc(_f(x).f2mul_(y, z, **kwds) for x, y, z in zip(xs, ys, zs))
     return float(D)
 
 
 def fhorner(x, *cs, **incx):
-    '''Horner form evaluation of polynomial M{sum(cs[i] * x**i for
-       i=0..n)} with in- or decreasing exponent M{sum(... i=n..0)},
-       where C{n = len(cs) - 1}.
+    '''Horner form evaluation of polynomial M{sum(cs[i] * x**i for i=0..n)} as
+       in- or decreasing exponent M{sum(... i=n..0)}, where C{n = len(cs) - 1}.
 
        @return: Horner sum (C{float}).
 
@@ -804,7 +806,7 @@ def fremainder(x, y):
     return r
 
 
-if _sys_version_info2 < (3, 8):  # PYCHOK no cover
+if _MODS.sys_version_info2 < (3, 8):  # PYCHOK no cover
     from math import hypot  # OK in Python 3.7-
 
     def hypot_(*xs):
@@ -831,7 +833,7 @@ if _sys_version_info2 < (3, 8):  # PYCHOK no cover
         '''
         return float(_Hypot(*xs))
 
-elif _sys_version_info2 < (3, 10):
+elif _MODS.sys_version_info2 < (3, 10):
     # In Python 3.8 and 3.9 C{math.hypot} is inaccurate, see
     # U{agdhruv<https://GitHub.com/geopy/geopy/issues/466>},
     # U{cffk<https://Bugs.Python.org/issue43088>} and module

pygeodesy/formy.py

@@ -20,11 +20,11 @@ from pygeodesy.errors import IntersectionError, LimitError, limiterrors, \
                             _xcallable,_xkwds, _xkwds_pop2
 from pygeodesy.fmath import euclid, hypot, hypot2, sqrt0
 from pygeodesy.fsums import fsumf_,  Fmt, unstr
-# from pygeodesy.internals import _dunder_nameof  # from .named
+# from pygeodesy.internals import _DUNDER_nameof  # from .named
 from pygeodesy.interns import _delta_, _distant_, _inside_, _SPACE_, _too_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name__, _name2__, _NamedTuple, _xnamed, \
-                            _dunder_nameof
+                            _DUNDER_nameof
 from pygeodesy.namedTuples import Bearing2Tuple, Distance4Tuple, LatLon2Tuple, \
                                   Intersection3Tuple, PhiLam2Tuple, Vector3Tuple
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
@@ -43,7 +43,7 @@ from contextlib import contextmanager
 from math import asin, atan, atan2, cos, degrees, fabs, radians, sin, sqrt  # pow
 
 __all__ = _ALL_LAZY.formy
-__version__ = '24.09.27'
+__version__ = '24.10.14'
 
 _RADIANS2 = (PI / _180_0)**2  # degrees- to radians-squared
 _ratio_   = 'ratio'
@@ -1136,7 +1136,7 @@ class _idllmn6(object):  # see also .geodesicw._wargs, .latlonBase._toCartesian3
                 _, lat2, lon2 = _Wrap.latlon3(lon1, lat2, lon2, wrap)
                 kwds = _xkwds(kwds, wrap=wrap)  # for _xError
             m =  small if small is _100km else Meter_(small=small)
-            n = _dunder_nameof(intersections2 if s else intersection2)
+            n = _DUNDER_nameof(intersections2 if s else intersection2)
             if datum is None or euclidean(lat1, lon1, lat2, lon2) < m:
                 d, m = None, _MODS.vector3d
                 _i   = m._intersects2 if s else m._intersect3d3
@@ -1156,7 +1156,7 @@ class _idllmn6(object):  # see also .geodesicw._wargs, .latlonBase._toCartesian3
                         m = _MODS.ellipsoidalKarney
                     except ImportError:
                         m = _MODS.ellipsoidalExact
-                    _i = m._intersections2 if s else m._intersection3  # ellispoidalBaseDI
+                    _i = m._intersections2 if s else m._intersection3  # ellipsoidalBaseDI
                 else:
                     raise _TypeError(datum=datum)
             yield _i, d, lat2, lon2, m, n
@@ -1231,7 +1231,8 @@ def intersection2(lat1, lon1, bearing1,
 
         else:
             t = _i(m.LatLon(lat1, lon1, datum=d), b1,
-                   m.LatLon(lat2, lon2, datum=d), b2, height=0, wrap=False)
+                   m.LatLon(lat2, lon2, datum=d), b2,
+                     LatLon=None, height=0, wrap=False)
             if isinstance(t, Intersection3Tuple):  # ellipsoidal
                 t, _, _ = t
             t = LatLon2Tuple(t.lat, t.lon, name=n)