pygeodesy 24.10.24__py2.py3-none-any.whl → 24.12.12__py2.py3-none-any.whl

pygeodesy/etm.py

@@ -11,13 +11,13 @@ 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>}
 file C{Header}.
 
-Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2008-2023) and licensed
+Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2008-2024) and licensed
 under the MIT/X11 License.  For more information, see the U{GeographicLib<https://
 GeographicLib.SourceForge.io>} documentation.
 
@@ -65,38 +65,40 @@ 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
+from pygeodesy.utily import atan1d, atan2, atan2d, _loneg, sincos2
 from pygeodesy.utm import _cmlon, _LLEB, _parseUTM5, _toBand, _toXtm8, \
                           _to7zBlldfn, Utm, UTMError
 
-from math import asinh, atan2, degrees, radians, sinh, sqrt
+from math import asinh, degrees, radians, sinh, sqrt
 
 __all__ = _ALL_LAZY.etm
-__version__ = '24.10.21'
+__version__ = '24.11.24'
 
-_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,52 +1149,46 @@ 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.13 -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
+# % 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
+# % 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 -m pygeodesy.etm -s -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
+# % 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
+# % 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
 
@@ -1189,7 +1197,7 @@ if __name__ == '__main__':  # MCCABE 16
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/fmath.py

@@ -12,9 +12,8 @@ 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, _ALL_MODS as _MODS
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
@@ -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.11'
+__version__ = '24.12.02'
 
 # 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):
@@ -115,21 +107,23 @@ class Fhypot(Fsum):
                        other settings, see class L{Fsum<Fsum.__init__>} and method
                        L{root<Fsum.root>}.
         '''
+        def _r_X_kwds(power=None, raiser=True, root=2, **kwds):
+            # DEPRECATED keyword argument C{power=2}, use C{root=2}
+            return (root if power is None else power), raiser, kwds
+
         r = None  # _xkwds_pop2 error
         try:
-            r, kwds = _xkwds_pop2(root_name_f2product_nonfinites_RESIDUAL_raiser, root=2)
-            r, kwds = _xkwds_pop2(kwds, power=r)  # for backward compatibility
-            t, kwds = _xkwds_pop2(kwds, raiser=True)
+            r, X, kwds = _r_X_kwds(**root_name_f2product_nonfinites_RESIDUAL_raiser)
             Fsum.__init__(self, **kwds)
             self(_0_0)
             if xs:
-                self._facc_power(r, xs, Fhypot, raiser=t)
-            self._fset(self.root(r, raiser=t))
+                self._facc_power(r, xs, Fhypot, raiser=X)
+            self._fset(self.root(r, raiser=X))
         except Exception as X:
             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 +144,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):
@@ -173,11 +165,11 @@ class Fpowers(Fsum):
                        L{fpow<Fsum.fpow>}.
         '''
         try:
-            t, kwds = _xkwds_pop2(name_f2product_nonfinites_RESIDUAL_raiser, raiser=True)
+            X, kwds = _xkwds_pop2(name_f2product_nonfinites_RESIDUAL_raiser, raiser=True)
             Fsum.__init__(self, **kwds)
             self(_0_0)
             if xs:
-                self._facc_power(power, xs, Fpowers, raiser=t)  # x**0 == 1
+                self._facc_power(power, xs, Fpowers, raiser=X)  # x**0 == 1
         except Exception as X:
             raise self._ErrorXs(X, xs, power=power)
 
@@ -197,12 +189,12 @@ class Froot(Fsum):
                        L{fpow<Fsum.fpow>}.
         '''
         try:
-            raiser, kwds = _xkwds_pop2(name_f2product_nonfinites_RESIDUAL_raiser, raiser=True)
+            X, kwds = _xkwds_pop2(name_f2product_nonfinites_RESIDUAL_raiser, raiser=True)
             Fsum.__init__(self, **kwds)
             self(_0_0)
             if xs:
                 self.fadd(xs)
-            self(self.root(root, raiser=raiser))
+            self(self.root(root, raiser=X))
         except Exception as X:
             raise self._ErrorXs(X, xs, root=root)
 
@@ -431,35 +423,47 @@ 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
-               positional.
-       @kwarg start: Optional bias C{B{start}=0} (C{scalar}, an L{Fsum} or
-                     L{Fsum2Tuple}).
+       @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_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: X values iterable (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
+       @arg ys: Y values iterable (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
+       @arg zs: Z values iterable (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
 
-       @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 +473,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}).
 
@@ -1092,7 +1095,7 @@ def zqrt(x):
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),