pygeodesy 25.12.12__py2.py3-none-any.whl → 25.12.31__py2.py3-none-any.whl

pygeodesy/fsums.py

@@ -5,16 +5,16 @@ u'''Class L{Fsum} for precision floating point summation similar to
 Python's C{math.fsum}, but enhanced with I{precision running} summation
 plus optionally, accurate I{TwoProduct} multiplication.
 
-Accurate multiplication is based on the C{math.fma} function from
-Python 3.13 and newer or an equivalent C{fma} implementation for
-Python 3.12 and older.  To enable accurate multiplication, set env
-variable C{PYGEODESY_FSUM_F2PRODUCT} to C{"std"} or any non-empty
-string or invoke function C{pygeodesy.f2product(True)} or set.  With
-C{"std"} the C{fma} implemention follows the C{math.fma} function,
-otherwise the C{PyGeodesy 24.09.09} release.
+Accurate multiplication is based on the C{math.fma} function from Python
+3.13 and newer or an equivalent C{fma} implementation for Python 3.12 and
+older.  Set env variable C{PYGEODESY_FSUM_F2PRODUCT} to C{"std"} or any
+non-empty string or invoke function C{pygeodesy.f2product(True)} to enable
+accurate multiplication.  With C{"std"} the C{fma} implemention follows
+the C{math.fma} function, otherwise the implementation of the C{PyGeodesy
+24.09.09} release.
 
 Generally, an L{Fsum} instance is considered a C{float} plus a small or
-zero C{residue} aka C{residual} value, see property L{Fsum.residual}.
+zero C{residue} aka C{residual}, see property L{Fsum.residual}.
 
 Set env variable C{PYGEODESY_FSUM_RESIDUAL} to a C{float} string greater
 than C{"0.0"} as the threshold to throw a L{ResidualError} for a division,
@@ -28,7 +28,7 @@ L{Fsum.fint2} and L{Fsum.is_integer}.  Also, L{Fsum} methods L{Fsum.pow},
 L{Fsum.__ipow__}, L{Fsum.__pow__} and L{Fsum.__rpow__} return a (very long)
 C{int} if invoked with optional argument C{mod} set to C{None}.  The
 C{residual} of an C{integer} L{Fsum} is between C{-1.0} and C{+1.0} and
-will be C{INT0} if that is considered to be I{exact}.
+will be C{INT0} if that L{Fsum} is an I{exact float} or I{exact integer}.
 
 Set env variable C{PYGEODESY_FSUM_NONFINITES} to C{"std"} or use function
 C{pygeodesy.nonfiniterrors(False)} to allow I{non-finite} C{float}s like
@@ -62,7 +62,7 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '25.06.03'
+__version__ = '25.12.24'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -321,8 +321,8 @@ def nonfiniterrors(raiser=None):
     '''
     d = Fsum._isfine
     if raiser is not None:
-        Fsum._isfine = {} if bool(raiser) else Fsum._nonfinites_isfine_kwds[True]
-    return (False if d is Fsum._nonfinites_isfine_kwds[True] else
+        Fsum._isfine = {} if bool(raiser) else _nonfinites_isfine_kwds[True]
+    return (False if d is _nonfinites_isfine_kwds[True] else
          _xkwds_get1(d, _isfine=_isfinite) is _isfinite) if d else True
 
 
@@ -370,7 +370,7 @@ def _Psum(ps, **name_f2product_nonfinites_RESIDUAL):
     return F
 
 
-def _Psum_(*ps, **name_f2product_nonfinites_RESIDUAL):  # in .fmath
+def _Psum_(*ps, **name_f2product_nonfinites_RESIDUAL):
     '''(INTERNAL) Return an C{Fsum} from I{known scalar} C{ps}.
     '''
     return _Psum(ps, **name_f2product_nonfinites_RESIDUAL)
@@ -486,7 +486,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
        @note: Handling of I{non-finites} as C{inf}, C{INF}, C{NINF}, C{nan} and C{NAN} is
               determined by function L{nonfiniterrors<fsums.nonfiniterrors>} for the default
-              and by method L{nonfinites<Fsum.nonfinites>} for individual C{Fsum} instances,
+              or by method L{nonfinites<Fsum.nonfinites>} for individual C{Fsum} instances,
               overruling the default.  For backward compatibility, I{non-finites} raise
               exceptions by default.
 
@@ -829,7 +829,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         return self._cmp_0(other, _lt_op_ + _fset_op_) <= 0
 
     def __len__(self):
-        '''Return the number of values accumulated (C{int}).
+        '''Return the number of (non-zero) values accumulated (C{int}).
         '''
         return self._n
 
@@ -1447,7 +1447,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            @arg other2: Addend (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @kwarg nonfinites: Use C{B{nonfinites}=True} or C{False}, to
                               override L{nonfinites<Fsum.nonfinites>} and
-                              L{nonfiniterrors} default (C{bool}).
+                              the L{nonfiniterrors} default (C{bool}).
         '''
         op  = typename(self.fma)
         _fs = self._ps_other
@@ -1479,7 +1479,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                      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}).
+                              the L{nonfiniterrors} default (C{bool}).
 
            @note: Equivalent to L{fdot_<pygeodesy.fmath.fdot_>}C{(*xys,
                   start=self)}.
@@ -1615,8 +1615,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         if two:  # delattrof(self, _f2product=None)
             t = _xkwds_pop(self.__dict__, _f2product=None)
-            if two[0] is not None:
-                self._f2product = bool(two[0])
+            self._optionals(f2product=two[0])
         else:  # getattrof(self, _f2product=None)
             t = _xkwds_get(self.__dict__, _f2product=None)
         return t
@@ -2070,25 +2069,21 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            @see: Function L{nonfiniterrors<fsums.nonfiniterrors>}.
 
            @note: Use property L{nonfinitesOK<Fsum.nonfinitesOK>} to determine
-                  whether I{non-finites} are C{OK} for this L{Fsum} and by the
+                  whether I{non-finites} are C{OK} for this L{Fsum} or by the
                   L{nonfiniterrors} default.
         '''
-        _ks = Fsum._nonfinites_isfine_kwds
         if OK:  # delattrof(self, _isfine=None)
             k = _xkwds_pop(self.__dict__, _isfine=None)
-            if OK[0] is not None:
-                self._isfine = _ks[bool(OK[0])]
+            self._optionals(nonfinites=OK[0])
             self._update()
         else:  # getattrof(self, _isfine=None)
             k = _xkwds_get(self.__dict__, _isfine=None)
+        _ks = _nonfinites_isfine_kwds
         # dict(map(reversed, _ks.items())).get(k, None)
         # raises a TypeError: unhashable type: 'dict'
         return True  if k is _ks[True]  else (
                False if k is _ks[False] else None)
 
-    _nonfinites_isfine_kwds = {True:  dict(_isfine=_isOK),
-                               False: dict(_isfine=_isfinite)}
-
     @property_RO
     def nonfinitesOK(self):
         '''Are I{non-finites} C{OK} for this L{Fsum} or by default? (C{bool}).
@@ -2111,9 +2106,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''(INTERNAL) Re/set options from keyword arguments.
         '''
         if f2product is not None:
-            self.f2product(f2product)
+            self._f2product = bool(f2product)
         if nonfinites is not None:
-            self.nonfinites(nonfinites)
+            self._isfine = _nonfinites_isfine_kwds[bool(nonfinites)]
         if name_RESIDUAL:  # MUST be last
             n, kwds = _name2__(**name_RESIDUAL)
             if kwds:
@@ -2535,6 +2530,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
 _ROs = _allPropertiesOf_n(3, Fsum, Property_RO)  # PYCHOK see Fsum._update
 
+_nonfinites_isfine_kwds = {True:  dict(_isfine=_isOK),
+                           False: dict(_isfine=_isfinite)}
 if _NONFINITES == _std_:  # PYCHOK no cover
     _ = nonfiniterrors(False)
 
@@ -2685,6 +2682,21 @@ class Fsum2Tuple(_NamedTuple):  # in .fstats
 _Fsum_2Tuple_types = Fsum, Fsum2Tuple  # PYCHOK lines
 
 
+class _Ksum(Fsum):
+    '''(INTERNAL) For C{.karney._sum3}, specifically and only.
+    '''
+    _isfine = _nonfinites_isfine_kwds[True]
+
+    def __init__(self, s, t, *xs):
+        ps = [t, s] if t else [s]
+        self._ps = self._ps_acc(ps, xs, up=False)
+
+    @property_RO
+    def _s_t_n3(self):
+        s, t = self._fprs2
+        return s, t, self._n
+
+
 class ResidualError(_ValueError):
     '''Error raised for a division, power or root operation of
        an L{Fsum} instance with a C{residual} I{ratio} exceeding

pygeodesy/geod3solve.py

@@ -5,13 +5,14 @@ u'''Wrapper to invoke I{Karney}'s U{Geod3Solve
 <https://GeographicLib.SourceForge.io/C++/doc/Geod3Solve.1.html>} utility
 as a C{triaxial} geodesic, but intended I{mainly for testing purposes}.
 
-Set env variable C{PYGEODESY_GEOD3SOLVE} to the (fully qualified) path
-of the C{Geod3Solve} executable.
+Set env variable C{PYGEODESY_GEOD3SOLVE} to the (fully qualified) path of
+the C{Geod3Solve} executable or use property L{Geodesic3Solve.Geod3Solve
+<geod3solve._Geodesic3SolveBase.Geod3Solve>}.
 '''
 
 from pygeodesy.angles import Ang, Deg, isAng,  hypot
 from pygeodesy.basics import _xinstanceof  # typename
-from pygeodesy.constants import _0_0, _0_5, _360_0
+from pygeodesy.constants import _0_0, _0_5, _360_0, _over
 from pygeodesy.errors import GeodesicError, _xkwds_get
 # from pygeodesy.fmath import hypot  # from .angles
 # from pygeodesy.geodesicx import GeodesicAreaExact  # _MODS
@@ -25,7 +26,7 @@ from pygeodesy.units import Degrees, Meter
 # from pygeodesy.utily import sincos2d  # from .karney
 
 __all__ = _ALL_LAZY.geod3solve
-__version__ = '25.12.12'
+__version__ = '25.12.31'
 
 _Triaxial3_WGS84 = Triaxial3s.WGS84_3r  # a=6378172, b=6378102, c=6356752
 
@@ -39,8 +40,8 @@ class Geodesic3Error(GeodesicError):
 class Geod3Solve8Tuple(_GTuple):
     '''8-Tuple C{(bet1, omg1, alp1, bet2, omg2, alp2, s12, a12)} with C{ellipsoidal}
        latitudes C{bet1} and C{bet2}, C{ellipsoidal} longitudes C{omg1} and C{omg2},
-       forward azimuths C{alp1} and C{alp2} in bearings from North, distanc C{s12} in
-       C{meter}, conventionally and I{approximate} arc length {a12} in degrees, see
+       forward azimuths C{alp1} and C{alp2} in bearings from North, distance C{s12} in
+       C{meter}, conventionally and I{approximate} arc length C{a12} in degrees, see
        U{Geod3Solve<https://GeographicLib.SourceForge.io/C++/doc/Geod3Solve.1.html>}.
     '''
     # from Geod3Solve --help option -f ... bet1 omg1 alp1 bet2 omg2 alp2 s12
@@ -161,11 +162,11 @@ class Geodesic3Solve(_Geodesic3SolveBase):
         '''
         a = r.s12 or _0_0
         if a:
+            t = self.triaxial3
             z = _toAzi(r.alp1) + _toAzi(r.alp2)
             s, c = sincos2d(z * _0_5)
-            t  = self.triaxial3
-            a *= hypot(s / t._ab_elliperim,  # azimuth!
-                       c / t._bc_elliperim) * _360_0
+            a *= hypot(_over(s, t.perimeter4ab),  # azimuth!
+                       _over(c, t.perimeter4bc)) * _360_0
         r[_a12_] = a
         return r
 

pygeodesy/geodesici.py

@@ -7,10 +7,11 @@ Class L{Intersector} is a pure Python version of I{Karney}'s C++ class U{Interse
 <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Intersect.html>}.
 
 Class L{Intersectool} is a wrapper to invoke I{Karney}'s U{IntersectTool
-<https://GeographicLib.SourceForge.io/C++/doc/IntersectTool.1.html>} utility, but intended I{for testing purposes only}.
+<https://GeographicLib.SourceForge.io/C++/doc/IntersectTool.1.html>} utility, mainly intended I{for testing purposes}.
 
-Set env variable C{PYGEODESY_INTERSECTTOOL} to the (fully qualified) path of the C{IntersectTool} executable.  For usage
-and some examples run C{"env PYGEODESY_INTERSECTTOOL=<IntersectTool-path> python3 -m pygeodesy.geodesici --help"}.
+Set env variable C{PYGEODESY_INTERSECTTOOL} to the (fully qualified) path of the C{IntersectTool} executable or use
+property L{Intersectool.IntersectTool}.  For usage and some examples run C{"env PYGEODESY_INTERSECTTOOL=<IntersectTool-path>
+python3 -m pygeodesy.geodesici --help"}.
 
 Both L{Intersectool} and L{Intersector} provide methods C{All}, C{Closest}, C{Next} and C{Segment} and produce
 L{XDict} instances with 4 or more items.  Adjacent methods C{All5}, C{Closest5}, C{Next5} and C{Segment} return
@@ -57,7 +58,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.06.02'
+__version__ = '25.12.31'
 
 _0t     =  0,  # int
 _1_1t   = -1, +1

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.09.02'
+__version__ = '25.12.23'
 
 # **) MIT License
 #

pygeodesy/geodesicx/gxarea.py

@@ -19,19 +19,20 @@ from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _copysign, isodd, unsigned0
 from pygeodesy.constants import NAN, _0_0, _0_5, _720_0
+from pygeodesy.fmath import _fma
 from pygeodesy.internals import printf, typename
 # from pygeodesy.interns import _COMMASPACE_  # from .lazily
 from pygeodesy.karney import Area3Tuple, _diff182, GeodesicError, \
-                            _norm180, _remainder, _sum3
+                            _norm180, _remainder, _sum2
 from pygeodesy.lazily import _ALL_DOCS,  _COMMASPACE_
 from pygeodesy.named import ADict, callername, _NamedBase,  pairs
 from pygeodesy.props import Property, Property_RO, property_RO
 # from pygeodesy.streprs import pairs  # from .named
 
-from math import fmod as _fmod
+from math import fabs, fmod as _fmod
 
 __all__ = ()
-__version__ = '25.09.16'
+__version__ = '25.12.23'
 
 
 class GeodesicAreaExact(_NamedBase):
@@ -427,30 +428,39 @@ class _Accumulator(_NamedBase):
            @kwarg y: Initial value (C{scalar}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
         '''
-        if isinstance(y, _Accumulator):
-            self._s, self._t, self._n = y._s, y._t, 1
-        elif y:
-            self._s, self._n = float(y), 1
+        self._s_t(*_s_t2(y))
+        self._n = 1
         if name:
             self.name = name
 
-    def Add(self, y):
-        '''Add a value.
+    def Add(self, *ys):
+        '''Add one or more scalars or L{_Accumulator}s.
 
            @return: Current C{sum}.
-        '''
-        self._n += 1
-        self._s, self._t, _ = _sum3(self._s, self._t, y)
-        return self._s  # current .Sum()
+
+           @see: C++ U{Accumulator.Add<https://GeographicLib.sourceforge.io/C++/doc/Accumulator_8hpp_source.html>}
+                 for more details about Karney's and Shewchuk's addition.
+        '''
+        # _Accumulator().Add(1, 1e20, 2, 100, 5000, -1e20) ... 5103.0
+        s, t = self._s, self._t
+        for y in ys:
+            for y in _s_t2(y):
+                if y:
+                    t, u = _sum2(t, y)
+                    s, t = _sum2(s, t)
+                    if s:  # accumlate u in t
+                        t += u
+                    else:  # s == 0 implies t == 0
+                        s  = u
+                    self._n += 1
+        return self._s_t(s, t)
 
     def Negate(self):
         '''Negate sum.
 
            @return: Current C{sum}.
         '''
-        self._s = s = -self._s
-        self._t =     -self._t
-        return s  # current .Sum()
+        return self._s_t(-self._s, -self._t)
 
     @property_RO
     def num(self):
@@ -459,22 +469,27 @@ class _Accumulator(_NamedBase):
         return self._n
 
     def Remainder(self, y):
-        '''Remainder on division by B{C{y}}.
+        '''Remainder of division by B{C{y}}.
 
            @return: Remainder of C{sum} / B{C{y}}.
         '''
-        self._s = _remainder(self._s, y)
-#       self._t = _remainder(self._t, y)
-        self._n = -1
-        return self.Add(_0_0)
+        return self._s_t(_remainder(self._s, y),
+                         _remainder(self._t, y))
 
     def Reset(self, y=0):
-        '''Set value from argument.
+        '''Reset from scalar or L{_Accumulator}.
         '''
-        self._n, self._s, self._t = 0, float(y), _0_0
+        self._s_t(*_s_t2(y))
+        self._n = 0
 
     Set = Reset
 
+    def _s_t(self, s, t=0):
+        if t and fabs(s) < fabs(t):
+            s, t = t, s
+        self._s, self._t = s, t
+        return s
+
     def Sum(self, y=0):
         '''Return C{sum + B{y}}.
 
@@ -488,6 +503,17 @@ class _Accumulator(_NamedBase):
             s = self
         return s._s
 
+    def Times(self, y):
+        '''Multiply by a scalar.
+
+           @return: Current C{sum}.
+        '''
+        s  = d = self._s
+        s *= y
+        d = _fma(y, d, -s)
+        t = _fma(y, self._t, d)
+        return self._s_t(s, t)  # current .Sum()
+
     def toStr(self, prec=6, sep=_COMMASPACE_, **unused):  # PYCHOK signature
         '''Return this C{_Accumulator} as string.
 
@@ -502,6 +528,10 @@ class _Accumulator(_NamedBase):
         return sep.join(pairs(d, prec=prec))
 
 
+def _s_t2(y):
+    return (y._s, y._t) if isinstance(y, _Accumulator) else (float(y),)  # PYCHOK OK
+
+
 __all__ += _ALL_DOCS(GeodesicAreaExact, PolygonArea)
 
 # **) MIT License

pygeodesy/geodsolve.py

@@ -5,8 +5,9 @@ u'''Wrapper to invoke I{Karney}'s U{GeodSolve
 <https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>} utility
 as an (exact) geodesic, but intended I{mainly for testing purposes}.
 
-Set env variable C{PYGEODESY_GEODSOLVE} to the (fully qualified) path
-of the C{GeodSolve} executable.
+Set env variable C{PYGEODESY_GEODSOLVE} to the (fully qualified) path of
+the C{GeodSolve} executable or use property L{GeodesicSolve.GeodSolve
+<geodsolve._GeodesicSolveBase.GeodSolve>}.
 '''
 
 from pygeodesy.basics import _xinstanceof  # typename
@@ -28,7 +29,7 @@ from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '25.12.06'
+__version__ = '25.12.31'
 
 
 class GeodSolve12Tuple(_GTuple):

pygeodesy/karney.py

@@ -153,14 +153,14 @@ in C{pygeodesy} are based on I{Karney}'s post U{Area of a spherical polygon
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # noqa: E702 ;
 
-from pygeodesy.basics import _copysign, _isin, isint, neg, unsigned0, \
-                             _xgeographiclib, _zip
+from pygeodesy.basics import _copysign, _isin, isint, neg, _xgeographiclib, _zip
 from pygeodesy.constants import NAN, _isfinite as _math_isfinite, \
                                _0_0, _1_0, _2_0, _180_0, _N_180_0, _360_0
 # from pygeodesy.deprecated.classes import Rhumb7Tuple  # _MODS
 from pygeodesy.errors import GeodesicError, _ValueError, _xkwds
 # from pygeodesy.geod3Solve import Geod3Solve8Tuple  # _MODS
-from pygeodesy.fmath import cbrt, fremainder, norm2  # Fhorner, Fsum
+from pygeodesy.fmath import cbrt, fhorner, fremainder, norm2
+from pygeodesy.fsums import _Ksum
 from pygeodesy.internals import _getenv, _popen2, _PYGEODESY_ENV, typename, \
                                 _version_info
 from pygeodesy.interns import NN, _a12_, _area_, _azi2_, _azi12_, _composite_, \
@@ -177,7 +177,7 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '25.12.12'
+__version__ = '25.12.23'
 
 _1_16th     = _1_0 / 16
 _2_4_       = '2.4'
@@ -913,20 +913,18 @@ try:
 
 except ImportError:  # Python 3.12-
 
-    def _poly_fma(x, s, *cs):  # PYCHOK redef
-        t = _0_0
-        for c in cs:
-            s, t, _ = _sum3(s * x, t * x, c)
-        return s + t
+    def _poly_fma(x, *cs):  # PYCHOK redef
+        return fhorner(x, *cs, incx=False)
 
 #   def _poly_fma(x, s, *cs):
-#       S  = Fhorner(x, *cs, incx=False)
-#       S += s
-#       return float(S)
+#       t = _0_0
+#       for c in cs:
+#           s, t, _ = _sum3(s * x, t * x, c)
+#       return s + t
 
 def _polynomial(x, cs, i, j):  # PYCHOK shared
-    '''(INTERNAL) Like C++ C{GeographicLib.Math.hpp.polyval} but with a
-       signature and cascaded summation different from C{karney._sum3}.
+    '''(INTERNAL) Like C++ C{GeographicLib.Math.hpp.polyval} but
+       with a different signature and cascaded summation.
 
        @return: M{sum(x**(j - k - 1) * cs[k] for k in range(i, j)}
     '''
@@ -1007,18 +1005,18 @@ def _sum2(a, b):  # mimick geomath.Math.sum, actually sum2
         r = s - b
         t = s - r
         # elif C_CPP:  # Math::sum C/C++
-        #   r -= a; t -= b; t += r; t = -t
-        # else:
-        t = (a - r) + (b - t)
+        #   r -= a; t -= b; t += r; t = (-t) if s else s
+        # else:  # if s == 0: t = _copysign_0_0(s)
+        t = ((a - r) + (b - t)) if s else s
         # assert fabs(s) >= fabs(t)
         return s, t
 
 
 def _sum3(s, t, *xs):
-    '''Accumulate any B{C{xs}} into a previous C{_sum2(s, t)}.
+    '''Accumulate all B{C{xs}} scalars into a previous C{_sum2(s, t)}.
 
        @return: 3-Tuple C{(s, t, n)} where C{s} is the sum of B{s}, B{t} and all
-                B{xs}, C{t} the residual and C{n} the number of zero C{xs}.
+                B{xs}, C{t} the residual and C{n} the number of non-zero C{xs}.
 
        @see: I{Karney's} C++ U{Accumulator<https://GeographicLib.SourceForge.io/
              C++/doc/Accumulator_8hpp_source.html>} comments for more details and
@@ -1026,23 +1024,10 @@ def _sum3(s, t, *xs):
 
        @note: Not "error-free", see C{pygeodesy.test/testKarney.py}.
     '''
-    z = 0
-    for x in xs:
-        if x:
-            t, r = _sum2(t, x)  # start at the least-
-            if s:
-                s, t = _sum2(s, t)  # -significant end
-                if s:
-                    t += r  # accumulate r into t
-                else:
-                    # assert t == 0  # s == 0 implies t == 0
-                    s = unsigned0(r)  # result is r, t = 0
-            else:
-                s, t = unsigned0(t), r
-        else:
-            z += 1
-    # assert fabs(s) >= fabs(t)
-    return s, t, z
+    return _Ksum(s, t, *xs)._s_t_n3 if xs else (s, t, 0)
+    # previous _sum3 in .geodesicx.gxarea._Accumulator.Add
+    # which fails .fmath.frandoms tests, but does pass
+    # _sum3(1e20, 1, 2, 100, 5000, -1e20) ... 5103.0, 0.0, 4
 
 
 def _tand(x):

pygeodesy/lazily.py

@@ -250,7 +250,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'fpolynomial', 'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder',
                                    'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',
                                    'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'),
-                          formy=_a('Radical2Tuple',
+                          formy=_a('Elliperim', 'Radical2Tuple',
                                    'angle2chord', 'antipode', 'antipode_', 'bearing', 'bearing_',
                                    'chord2angle', 'compassAngle', 'cosineLaw', 'cosineLaw_',
                                    'elliperim', 'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_',
@@ -520,7 +520,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '25.12.12'
+__version__ = '25.12.23'
 
 
 def _ALL_OTHER(*objs):

pygeodesy/named.py

@@ -35,7 +35,7 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '25.11.29'
+__version__ = '25.11.13'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -1188,7 +1188,7 @@ def callername(up=1, dflt=NN, source=False, underOK=False):
 
        @return: The callable name (C{str}) or B{C{dflt}} if none found.
     '''
-    try:  # see .lazily._caller3
+    try:  # see .internals._caller3
         for u in range(up, up + 32):
             n, f, s = _caller3(u)
             if n and (underOK or n.startswith(_DUNDER_) or

pygeodesy/props.py

@@ -26,7 +26,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '25.05.26'
+__version__ = '25.12.31'
 
 _class_       = 'class'
 _DNL_         = _NL_ * 2  # PYCHOK used!
@@ -696,8 +696,10 @@ class DeprecationWarnings(object):
         '''
         return self._Warnings if _WARNINGS_X_DEV else None
 
-DeprecationWarnings = DeprecationWarnings()  # PYCHOK singleton
-_throwarning        = DeprecationWarnings.throw
+if not _FOR_DOCS:  # PYCHOK force epydoc
+    DeprecationWarnings = DeprecationWarnings()  # singleton
+    _throwarning        = DeprecationWarnings.throw
+# del _FOR_DOCS
 
 # **) MIT License
 #

pygeodesy/trf.py

@@ -1,9 +1,7 @@
 
 # -*- coding: utf-8 -*-
 
-u'''I{Veness}' Terrestrial Reference Frames (TRF).
-
-Classes L{RefFrame}, registry L{RefFrames} and L{TRFError}.
+u'''I{Veness}' Terrestrial Reference Frames (TRF), classes L{RefFrame}, registry L{RefFrames} and L{TRFError}.
 
 Transcoded from I{Chris Veness'} (C) 2006-2024 JavaScript originals U{latlon-ellipsoidal-referenceframe.js
 <https://GitHub.com/ChrisVeness/geodesy/blob/master/latlon-ellipsoidal-referenceframe.js>} and