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

pygeodesy/formy.py

@@ -8,26 +8,30 @@ from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _copysign, _isin  # _args_kwds_count2
 # from pygeodesy.cartesianBase import CartesianBase  # _MODS
-from pygeodesy.constants import EPS, EPS0, EPS1, PI, PI2, PI3, PI_2, R_M, \
+from pygeodesy.constants import EPS, EPS0, EPS1, EPS_2, PI, PI2, PI3, PI_2, R_M, \
                                _0_0s, float0_, isnon0, remainder, _umod_PI2, \
                                _0_0, _0_125, _0_25, _0_5, _1_0, _2_0, _4_0, \
                                _90_0, _180_0, _360_0
+from pygeodesy.constants import _3_0, _10_0, MANT_DIG as _DIG53  # PYCHOK used!
 from pygeodesy.datums import Datum, Ellipsoid, _ellipsoidal_datum, \
                             _mean_radius, _spherical_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
+# from pygeodesy.elliptic import Elliptic  # _MODS
 from pygeodesy.errors import IntersectionError, LimitError, limiterrors, \
                             _TypeError, _ValueError, _xattr, _xError, \
                             _xcallable, _xkwds, _xkwds_pop2
-from pygeodesy.fmath import euclid, fdot_, fprod, hypot, hypot2, sqrt0
-from pygeodesy.fsums import fsumf_,  Fmt, unstr
+from pygeodesy.fmath import euclid, fdot_, fhorner, fprod, hypot, hypot2, sqrt0
+from pygeodesy.fsums import fsum, fsumf_,  Fmt, unstr
 # from pygeodesy.internals import typename  # 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,  typename
+from pygeodesy.interns import _delta_, _distant_, _DOT_, _inside_, _SPACE_, _too_
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS
+from pygeodesy.named import callername, _name__, _name2__, _NamedTuple, \
+                           _xnamed,  typename
 from pygeodesy.namedTuples import Bearing2Tuple, Distance4Tuple, LatLon2Tuple, \
                                   Intersection3Tuple, PhiLam2Tuple
+from pygeodesy.props import property_ROnce
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
-# from pygeodesy.triaxials import _hartzell3  # _MODS
+# from pygeodesy.triaxials.triaxial5 import _hartzell3  # _MODS
 from pygeodesy.units import _isDegrees, _isHeight, _isRadius, Bearing, Degrees_, \
                              Distance, Distance_, Height, Lamd, Lat, Lon, Meter_, \
                              Phid, Radians, Radians_, Radius, Radius_, Scalar, _100km
@@ -42,13 +46,241 @@ from contextlib import contextmanager
 from math import atan, cos, degrees, fabs, radians, sin, sqrt  # pow
 
 __all__ = _ALL_LAZY.formy
-__version__ = '25.05.12'
+__version__ = '25.12.31'
 
 _RADIANS2 =  radians(_1_0)**2  # degree to radians-squared
 _ratio_   = 'ratio'
 _xline_   = 'xline'
 
 
+class Elliperim(object):
+    '''Singleton with various methods to compute the perimeter of an ellipse.
+    '''
+    _TOL53    =  sqrt(EPS_2)     # sqrt(pow(_0_5, _DIG53))
+    _TOL53_53 = _TOL53 / _DIG53  # "flat" b/a tolerance, 1.9e-10
+    # assert _DIG53 == 53
+
+    def AGM(self, a, b, maxit=_DIG53):
+        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{AGM
+           <https://PaulBourke.net/geometry/ellipsecirc>} (Arithmetic-Geometric Mean) method.
+
+           @kwarg maxit: Number of iterations (C{int}).
+
+           @raise ValueError: No convergence for B{C{maxit}} iterations.
+        '''
+        _, p, a, b = self._pab4(a, b)
+        if p is None:
+            c_ = []
+            ts = self._AGMs(a, b, max(maxit, _DIG53), c_)
+            p  = fsum(ts, nonfinites=True)
+            p *= PI / c_[0]
+        return p
+
+    def _AGMs(self, a, b, maxit, c_):
+        '''(INTERNAL) Yield the C{AGM} terms and final C{c}.
+        '''
+        c = a + b
+        yield c**2
+        m = -1
+        t = self._TOL53
+        for _ in range(maxit):  # 4..5 trips
+            b  = sqrt(a * b)
+            a  = c * _0_5
+            c  = a + b
+            d  = a - b
+            m *= 2
+            yield d**2 * m
+            if d <= (b * t):
+                break
+        else:
+            raise self._Error(maxit, d, b * t)
+        c_.append(c)  # kludge
+
+    def Arc43(self, a, b):
+        '''Return the perimeter (and arcs) of an ellipse with semi-axes C{a} and C{b}
+           with the U{4-Arc<https://PaulBourke.net/geometry/ellipsecirc>} approximation.
+
+           @return: 3-Tuple C{(p, Ra, Rb)} with perimeter C{p}, arc radius C{Ra} at the
+                    major and arc radius C{Rb} at the minor semi-axis.
+        '''
+        _r, p, a, b = self._pab4(a, b)
+        if p is None:
+            h = hypot(a, b)
+            p = atan2(b, a)
+            s, c = sincos2(p)
+            L  = (h - b) * _0_5
+            Ra =  L / c
+            Rb = (h - L) / s
+            p  = Rb * p + Ra * (PI_2 - p)
+            p *= _4_0
+        else:  # circle or flat
+            Ra, Rb = a, b
+        return (p, Rb, Ra) if _r else (p, Ra, Rb)
+
+#   def CR(self, a, b):
+#       '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using U{Rackauckas'
+#          <https://www.ChrisRackauckas.com/assets/Papers/ChrisRackauckas-The_Circumference_of_an_Ellipse.pdf>}
+#          approximation, also U{here<https://ExtremeLearning.com.AU/a-formula-for-the-perimeter-of-an-ellipse>}.
+#       '''
+#       _, p, a, b = self._pab4(a, b)
+#       if p is None:
+#           p  =   a + b
+#           h  = ((a - b) / p)**2
+#           p *= (fhorner(h, 135168, -85760,  -5568, 3867) /
+#                 fhorner(h, 135168, -119552, 22208, 345)) * PI
+#       return p
+
+    def E2k(self, a, b):
+        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} from the complete
+           elliptic integral of the 2nd kind L{E(k)<pygeodesy.elliptic.Elliptic.cE>}.
+        '''
+        return self._ellip2k(a, b, self._ellipE)
+
+    def e2k(self, a, b, E_alt=None):
+        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using U{SciPy's
+           ellipe<https://www.JohnDCook.com/perimeter_ellipse.html>} function or method
+           C{E_alt}, otherwise C{None}.
+
+           @kwarg E_alt: An other C{Elliperim}C{(a, b)} method to use in case C{SciPy's
+                         ellipe} is not available.
+        '''
+        p = self._ellipe
+        if p is not None:  # i.e. callable
+            p = self._ellip2k(a, b, p)
+        elif callable(E_alt):  # and E_alt is not Elliperim.e2k
+            p = E_alt(a, b)
+        return p
+
+    def _ellipE(self, k):
+        '''(INTERNAL) Get the complete C{elliptic} integeral C{E(k)}.
+        '''
+        return _MODS.elliptic.Elliptic(k).cE
+
+    @property_ROnce
+    def _ellipe(self):
+        '''(INTERNAL) Wrap function C{scipy.special.ellipe}, I{once}.
+        '''
+        try:
+            from scipy.special import ellipe
+
+            def _ellipe(k):
+                return float(ellipe(k))
+
+        except (AttributeError, ImportError):
+            _ellipe = None
+        return _ellipe  # overwrite property_ROnce
+
+    def _ellip2k(self, a, b, _ellip):
+        '''(INTERNAL) Helper for methods C{E2k} and C{e2k}.
+        '''
+        _, p, a, b = self._pab4(a, b)
+        if p is None:  # see .ellipsoids.Ellipsoid.L
+            k = _1_0 - (b / a)**2
+            p = _ellip(k) * a * _4_0
+        return p
+
+    def _Error(self, maxit, d, t):
+        return _ValueError(maxit=maxit, txt=Fmt.no_convergence(d, t))
+
+    def GK(self, a, b):
+        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{Gauss-Kummer
+           <https://www.JohnDCook.com/blog/2023/05/28/approximate-ellipse-perimeter>} series, and
+           U{here<https://www.MathsIsFun.com/geometry/ellipse-perimeter.html>}, C{B{b / a} > 0.75}.
+        '''
+        _, p, a, b = self._pab4(a, b)
+        if p is None:
+            p  =  a + b
+            h  = (a - b) / p
+            p *= fhorner(h**2, *self._GKs) * PI
+        return p
+
+    @property_ROnce
+    def _GKs(self):
+        '''(INTERNAL) Compute the Gauss-Kummer coefficients, I{once}.
+        '''
+        return (1, 1 / 4, 1 / 64, 1 / 256, 25 / 16384, 49 / 65536,
+                441 / 1048576, 1089 / 4194304)  # overwrite property_ROnce
+
+    def HG(self, a, b, maxit=_DIG53):
+        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{HG
+           <https://web.Tecnico.ULisboa.PT/~mcasquilho/compute/com/,ellips/PerimeterOfEllipse.pdf>}
+           (HyperGeometric Gauss-Kummer) series.
+
+           @kwarg maxit: Number of iterations (C{int}), sufficient for C{B{b / a} > 0.125}.
+
+           @raise ValueError: No convergence for B{C{maxit}} iterations.
+        '''
+        _, p, a, b = self._pab4(a, b)
+        if p is None:
+            p  =  a + b
+            h  = (a - b) / p
+            ts = self._HGs(h, max(maxit, _DIG53))
+            p *= fsum(ts, nonfinites=True) * PI
+        return p
+
+    def _HGs(self, h, maxit):
+        '''(INTERNAL) Yield the C{HG} terms.
+        '''
+        t =  s_ = -1
+        s = _1_0
+        yield s
+        for u in range(-1, maxit * 2, 2):
+            t *= u / (u + 3) * h
+            t2 = t**2
+            s += t2
+            yield t2
+            if s == s_:
+                break
+            s_ = s
+        else:
+            s -= s_ - t2
+            raise self._Error(maxit, t2, s)
+
+#   def LS(self, a, b):
+#       '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{Linderholm-Segal
+#          <https://www.JohnDCook.com/blog/2021/03/24/perimeter-of-an-ellipse>} formula, aka C{3/2 norm}.
+#       '''
+#       _, p, a, b = self._pab4(a, b)
+#       if p is None:
+#           p = pow(a, _1_5) + pow(b, _1_5)
+#           p = pow(p * _0_5, _2_3rd) * PI2
+#       return p
+
+    def _pab4(self, a, b):
+        _r = a < b
+        if _r:
+            a, b = b, a
+        if a > b:
+            if b > (a * self._TOL53_53):
+                p = None
+            elif b < 0:
+                t =  callername()  # underOK=True
+                t = _DOT_(typename(self), t)
+                raise _ValueError(unstr(t, a, b))
+            else:  # "flat"
+                p = a * _4_0
+        else:  # circle
+            p = a * PI2
+        return _r, p, a, b
+
+    def R2(self, a, b):
+        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using U{Ramanujan's
+           2nd<https://PaulBourke.net/geometry/ellipsecirc>} approximation, C{B{b / a} > 0.9}.
+        '''
+        _, p, a, b = self._pab4(a, b)
+        if p is None:
+            p  =  a + b
+            h  = (a - b) / p
+            h *= _3_0 * h
+            h /=  sqrt(_4_0 - h) + _10_0  # /= chokes PyChecker?
+            p *= (h + _1_0) * PI
+        return p
+
+if not _FOR_DOCS:  # PYCHOK force epydoc
+    Elliperim = Elliperim()  # singleton
+del _FOR_DOCS
+
+
 def angle2chord(rad, radius=R_M):
     '''Get the chord length of a (central) angle or I{angular} distance.
 
@@ -367,6 +599,15 @@ def _dS(fun_, radius, wrap, *lls, **adjust):
     return r * radius
 
 
+def elliperim(a, b):
+    '''Compute the perimeter of an ellipse with semi-axes C{a} and C{b}
+       using the C{Elliperim.e2k} or C{Elliperim.AGM} method.
+
+       @return: The perimeter (C{scalar}, same units as C{a} and C{b}).
+    '''
+    return Elliperim.e2k(a, b, Elliperim.E2k)
+
+
 def _ellipsoidal(earth, where):
     '''(INTERNAL) Helper for distances.
     '''
@@ -926,7 +1167,7 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
     n, kwds = _name2__(name_LatLon_and_kwds, name__=hartzell)
     try:
         D = _spherical_datum(earth, name__=hartzell)
-        r, h, i = _MODS.triaxials._hartzell3(pov, los, D.ellipsoid._triaxial)
+        r, h, i = _MODS.triaxials.triaxial5._hartzell3(pov, los, D.ellipsoid._triaxial)
 
         C = _MODS.cartesianBase.CartesianBase
         if kwds:
@@ -1663,7 +1904,7 @@ def vincentys_(phi2, phi1, lam21):
 
 # **) MIT License
 #
-# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2026 -- 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/frechet.py

@@ -906,7 +906,7 @@ if __name__ == _DMAIN_:
 
 # **) MIT License
 #
-# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2026 -- 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/fstats.py

@@ -804,7 +804,7 @@ __all__ += _ALL_DOCS(_FstatsBase, _FstatsNamed)
 
 # **) MIT License
 #
-# Copyright (C) 2021-2025 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2021-2026 -- 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/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
@@ -2863,7 +2875,7 @@ if __name__ == _DMAIN_:
 
 # **) MIT License
 #
-# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2026 -- 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/gars.py

@@ -344,7 +344,7 @@ __all__ += _ALL_DOCS(decode3,  # functions
 
 # **) MIT License
 #
-# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2026 -- 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"),