pygeodesy 24.8.24__py2.py3-none-any.whl → 24.9.9__py2.py3-none-any.whl

pygeodesy/fsums.py

@@ -4,6 +4,11 @@
 u'''Class L{Fsum} for precision floating point summation and I{running}
 summation based on, respectively similar to Python's C{math.fsum}.
 
+Class L{Fsum} also supports accurate multiplication for Python 3.13 and
+later, but as an option for older Python versions.  For more details, see
+method L{f2product<Fsum.f2product>}, class L{Fsum2product} and U{Accurate
+Sum and Dot Product<https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}.
+
 Generally, an L{Fsum} instance is considered a C{float} plus a small or zero
 C{residual} value, see property L{Fsum.residual}.  However, there are several
 C{integer} L{Fsum} cases, for example the result of C{ceil}, C{floor},
@@ -25,13 +30,13 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import isbool, iscomplex, isint, isscalar, \
                             _signOf, itemsorted, signOf, _xiterable, \
-                            _xiterablen,  _enquote
-from pygeodesy.constants import INT0, _isfinite, NEG0, _pos_self, \
+                            _xiterablen
+from pygeodesy.constants import INT0, _isfinite, MANT_DIG, NEG0, _pos_self, \
                                _0_0, _1_0, _N_1_0,  Float, Int
 from pygeodesy.errors import _OverflowError, _TypeError, _UnexpectedError, \
                              _ValueError, _xError, _xError2, _xkwds_get1, \
                              _xkwds_pop2
-# from pygeodesy.internals import _enquote  # from .basics
+from pygeodesy.internals import _enquote, _passarg
 from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DASH_, _DOT_, \
                              _EQUAL_, _from_, _LANGLE_, _NOTEQUAL_, \
                              _not_finite_, _PERCENT_, _PLUS_, \
@@ -47,7 +52,7 @@ from pygeodesy.streprs import Fmt, fstr, unstr
 from math import ceil as _ceil, fabs, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '24.08.13'
+__version__ = '24.09.10'
 
 _add_op_      = _PLUS_  # in .auxilats.auxAngle
 _eq_op_       = _EQUAL_ * 2  # _DEQUAL_
@@ -132,6 +137,81 @@ def _2floats(xs, origin=0, _X=_X_ps, _x=float):
               _xError(X, Fmt.INDEX(xs=i), x)
 
 
+try:  # MCCABE 14
+    from math import fma as _fma
+
+    def _2products(x, ys, **unused):
+        # TwoProductFMA U{Algorithm 3.5
+        # <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
+        for y in ys:
+            f = x * y
+            yield  f
+            yield _fma(x, y, -f)
+
+    _2split3s = _passarg  # NOP
+
+except ImportError:  # Python 3.12-
+
+    def _fma(*a_b_c):  # in .fmath
+        # mimick C{math.fma} from Python 3.13+
+        # <https://MomentsInGraphics.De/FMA.html>
+        # >>> a = 1.00000011920929
+        # >>> b = 53400708
+        # >>> c = -b
+        # >>> _fma(a, b, c)
+        # 6.365860485903399
+        # >>> (a * b) + c
+        # 6.3658604845404625
+
+        def _as_n_d(x):
+            try:
+                if _isfinite(x):
+                    # int.as_integer_ratio since 3.8
+                    return x.as_integer_ratio()
+            except (AttributeError, OverflowError, TypeError, ValueError):
+                pass
+            return float(x), 1
+
+        (na, da), (nb, db), (nc, dc) = map(_as_n_d, a_b_c)
+        n = na * nb * dc + da * db * nc
+        d = da * db * dc
+        return float(n / d)
+
+    def _2products(x, y3s, two=False):  # PYCHOK redef
+        # TwoProduct U{Algorithm 3.3
+        # <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
+        _, a, b = _2split3(x)
+        for y, c, d in y3s:
+            y *= x
+            yield y
+            if two:
+                yield b * d - (((y - a * c) - b * c) - a * d)
+#                   = b * d + (a * d - ((y - a * c) - b * c))
+#                   = b * d + (a * d + (b * c - (y - a * c)))
+#                   = b * d + (a * d + (b * c + (a * c - y)))
+            else:
+                yield a * c - y
+                yield b * c
+                if d:
+                    yield a * d
+                    yield b * d
+
+    _2FACTOR = pow(2, (MANT_DIG + 1) // 2) + 1
+
+    def _2split3(x):
+        # Split U{Algorithm 3.2
+        # <ttps://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
+        a  = c = x * _2FACTOR
+        a -= c - x
+        b  = x - a
+        return x, a, b
+
+    def _2split3s(xs):  # PYCHOK redef
+        return map(_2split3, xs)
+
+del MANT_DIG
+
+
 def _Fsumf_(*xs):  # floats=True, in .auxLat, ...
     '''(INTERNAL) An C{Fsum} of I{known scalars}.
     '''
@@ -325,6 +405,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
              file I{Modules/mathmodule.c} and the issue log U{Full precision summation
              <https://Bugs.Python.org/issue2819>}.
     '''
+    _f2product = _2split3s is _passarg  # True for 3.13+
+    _math_fma  = _fma if _f2product else None
     _math_fsum =  None
     _n         =  0
 #   _ps        = []  # partial sums
@@ -467,7 +549,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
     def __hash__(self):  # PYCHOK no cover
         '''Return this instance' C{hash}.
         '''
-        return hash(self._ps)  # XXX id(self)?
+        # @see: U{Notes for type implementors<https://docs.Python.org/
+        #       3/library/numbers.html#numbers.Rational>}
+        return hash(self.partials)  # tuple.__hash__()
 
     def __iadd__(self, other):
         '''Apply C{B{self} += B{other}} to this instance.
@@ -890,6 +974,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             f._ps = list(self._ps)  # separate list
         if not deep:
             f._n = 1
+        # assert f._f2product == self._f2product
         # assert f._Fsum is f
         return f
 
@@ -901,6 +986,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         f = _Named.copy(self, deep=False, name=n)
         f._ps = list(self._ps)  # separate list
         # assert f._n == self._n
+        # assert f._f2product == self._f2product
         # assert f._Fsum is f
         return f
 
@@ -1111,9 +1197,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
 #               raise self._Error(op, other, _AssertionError, txt__=signOf)
         return DivMod2Tuple(q, self)  # q is C{int} in Python 3+, but C{float} in Python 2-
 
-    def _fhorner(self, x, cs, op):  # in .fmath
+    def _fhorner(self, x, cs, op, incx=True):  # in .fmath
         '''(INTERNAL) Add an L{Fhorner} evaluation of polynomial
-           M{sum(cs[i] * x**i for i=0..len(cs)-1)}.
+           C{sum(cs[i] * B{x}**i for i=0..len(cs)-1) if B{incx}
+           else sum(... i=len(cs)-1..0)}.
         '''
         if _xiterablen(cs):
             H = Fsum(name__=self._fhorner)
@@ -1123,11 +1210,11 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
                 _mul = H._mul_scalar
                 x = _2float(x=x)
             if len(cs) > 1 and x:
-                for c in reversed(cs):
+                for c in (reversed(cs) if incx else cs):
                     H._fset_ps(_mul(x, op))
                     H._fadd(c, op, up=False)
             else:  # x == 0
-                H = cs[0]
+                H = cs[0] if cs else _0_0
             self._fadd(H, op)
         return self
 
@@ -1222,6 +1309,38 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         q = self._ftruediv(other, op, **raiser_RESIDUAL)  # == self
         return self._fset(q.floor)  # floor(q)
 
+    def fma(self, other1, other2):  #
+        '''Fused-multiply-add C{self *= B{other1}; self += B{other2}}.
+
+           @arg other1: A C{scalar}, an L{Fsum} or L{Fsum2Tuple} instance.
+           @arg other2: A C{scalar}, an L{Fsum} or L{Fsum2Tuple} instance.
+
+           @note: Uses C{math.fma} in Python 3.13+, provided C{self},
+                  B{C{other1}} and B{C{other2}} are all C{scalar}.
+        '''
+        if len(self._ps) == 1 and isscalar(other1, both=True) \
+                              and isscalar(other2, both=True):
+            p = _fma(self._ps[0], other1, other2)
+            self._ps[:] = self._finite(p, self.fma.__name__),
+            if other2:
+                self._n += 1
+        else:
+            self._f2mul(self.fma.__name__, other1)
+            self += other2
+        return self
+
+#   def _fma_scalar(self, op, x, *ys):  # in .karney
+#       '''(INTERNAL) Apply C{self.fma(B{x}, B{y}) for B{y} in B{ys}}
+#           for scalar C{x} and C{y}s.
+#       '''
+#       ps = self._ps
+#       if ps and ys:
+#           for y in ys:
+#               ps[:] = self._ps_acc(list(y), _2products(x, _2split3s(ps)))
+#           for p in (ps if op else()):
+#               self._finite(p, op)
+#       return self
+
     fmul = __imul__
 
     def _fmul(self, other, op):
@@ -1232,6 +1351,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
                 f = self._mul_Fsum(other, op)
             elif len(other._ps) != 1:  # and len(self._ps) == 1
                 f = other._mul_scalar(self._ps[0], op)
+            elif self._f2product:  # len(other._ps) == 1
+                f = self._mul_scalar(other._ps[0], op)
             else:  # len(other._ps) == len(self._ps) == 1
                 f = self._finite(self._ps[0] * other._ps[0])
         else:
@@ -1239,6 +1360,29 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             f = self._mul_scalar(s, op)
         return self._fset(f)  # n=len(self) + 1
 
+    def f2mul(self, *others):
+        '''Apply C{B{self} *= B{other} for B{other} in B{others}} where each B{other}
+           is C{scalar}, an L{Fsum} or L{Fsum2Tuple} applying accurate multiplication
+           as if L{f2product<Fsum.f2product>}C{=True}.
+
+           @see: U{Equations 2.3<https://www.TUHH.De/ti3/paper/rump/OzOgRuOi06.pdf>}
+        '''
+        return self._f2mul(self.f2mul.__name__, *others)
+
+    def _f2mul(self, op, *others):
+        '''(INTERNAL) See method C{f2mul}.
+        '''
+        P  = _Psum(self._ps)
+        ps =  P._ps
+        if ps and others:
+            for p in self._ps_other(op, *others):
+                pfs   = _2products(p, _2split3s(ps))
+                ps[:] =  P._ps_acc([], pfs, up=False)
+            for p in ps:
+                self._finite(p, op)
+            self._fset(P, op=op)
+        return self
+
     def fover(self, over, **raiser_RESIDUAL):
         '''Apply C{B{self} /= B{over}} and summate.
 
@@ -1276,6 +1420,24 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             f = self._pow(other, other, op, **raiser_RESIDUAL)
         return self._fset(f)  # n=max(len(self), 1)
 
+    def f2product(self, *two):
+        '''Turn this instance' accurate I{TwoProduct} multiplication or or off.
+
+           @arg two: If C{True}, turn I{TwoProduct} on, if C{False} off or if
+                     C{None} or if omitted, keep the current setting.
+
+           @return: The previous C{f2product} setting (C{bool}).
+
+           @see: On Python 3.13 and later I{TwoProduct} is based on I{TwoProductFMA}
+                 U{Algorithm 3.5<https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
+                 otherwise on the slower I{TwoProduct} and I{Split} U{Algorithms
+                 3.3 and 3.2<https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}.
+        '''
+        t = self._f2product
+        if two and two[0] is not None:
+            self._f2product = bool(two[0])
+        return t
+
     @Property
     def _fprs(self):
         '''(INTERNAL) Get and cache this instance' precision
@@ -1834,10 +1996,16 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         def _pfs(ps, fs):
             if len(ps) < len(fs):
                 ps, fs = fs, ps
+            if self._f2product:
+                ps   =  tuple(_2split3s(ps))
+                _xys = _2products
+            else:
+                def _xys(x, ys):
+                    return (x * y for y in ys)
+
             _fin = _isfinite
             for f in fs:
-                for p in ps:
-                    p *= f
+                for p in _xys(f, ps):
                     yield p if _fin(p) else self._finite(p, op)
 
         return Fsum()._facc_scalar(_pfs(self._ps, factors), up=False)
@@ -1849,6 +2017,16 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         for p in self._ps:
             yield -p
 
+    def _ps_other(self, op, *others):
+        '''(INTERNAL) Yield the partials of all C{other}s.
+        '''
+        for other in others:
+            if _isFsumTuple(other):
+                for p in other._ps:
+                    yield p
+            else:
+                yield self._scalar(other, op)
+
     def _ps_1sum(self, *less):
         '''(INTERNAL) Return the partials sum, 1-primed C{less} some scalars.
         '''
@@ -2034,6 +2212,15 @@ def _Float_Int(arg, **name_Error):
     return U(arg, **name_Error)
 
 
+def Fsum2product(*xs, **name_RESIDUAL):
+    '''Return an L{Fsum} with L{f2product<Fsum.f2product>} accurate
+       multiplication I{turned on}.
+    '''
+    F = Fsum(*xs, **name_RESIDUAL)
+    F.f2product(True)
+    return F
+
+
 class DivMod2Tuple(_NamedTuple):
     '''2-Tuple C{(div, mod)} with the quotient C{div} and remainder
        C{mod} results of a C{divmod} operation.

pygeodesy/geodesici.py

@@ -28,8 +28,9 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 from pygeodesy.basics import _copy, _enumereverse, map1, \
                              _xinstanceof, _xor
 from pygeodesy.constants import EPS, INF, INT0, PI, PI2, PI_4, \
-                               _0_0, _0_5, _1_0, _1_5, _2_0, _3_0, \
-                               _90_0, isfinite
+                               _0_0, _0_5, _1_0, _1_5, _2_0, \
+                               _3_0, _64_0, _90_0, isfinite, \
+                               _EPSjam  # PYCHOK used!
 from pygeodesy.ellipsoids import _EWGS84,  Fmt, unstr
 from pygeodesy.errors import GeodesicError, IntersectionError, _an, \
                             _xgeodesics, _xkwds_get, _xkwds_kwds, \
@@ -56,7 +57,7 @@ from pygeodesy.utily import sincos2,  atan2, fabs, radians
 # from math import atan2, ceil as _ceil, fabs, radians  # .fsums, .utily
 
 __all__ = _ALL_LAZY.geodesici
-__version__ = '24.07.25'
+__version__ = '24.08.28'
 
 _0t     =  0,  # int
 _1_1t   = -1, +1
@@ -1237,7 +1238,7 @@ class Intersector(_IntersectBase):
         return sx, zx, sAx, sBx
 
     def _polarB3(self, lats=False):  # PYCHOK no cover
-        latx =  64.0
+        latx = _64_0
         lat  = _90_0 - latx
         if self.f:
             _d, _pD2 =  fdot, self._polarDist2
@@ -1393,7 +1394,7 @@ class Intersector(_IntersectBase):
 
     @Property_RO
     def _Tol(self):  # convergence tolerance
-        return self._cHalf * pow(EPS, 0.75)  # _0_75
+        return self._cHalf * _EPSjam
 
     def toStr(self, **prec_sep_name):  # PYCHOK signature
         '''Return this C{Intersector} as string.

pygeodesy/geodesicx/_C4_24.py

@@ -13,7 +13,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 from pygeodesy.geodesicx.gxbases import _Gfloats, _f, _f2
 
 __all__ = ()
-__version__ = '23.08.19'
+__version__ = '24.09.04'
 
 _g = _Gfloats(24)
 _coeffs_24 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 24
@@ -1672,8 +1672,6 @@ _coeffs_24 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 24
     # C4[23], coeff of eps^23, polynomial in n of order 0
     _f(1 << 41), _f(0xc5e28ed2c935ab),  # PYCHOK exported
 ))  # 2900 / 2708
-if __name__ == '__main__':
-    _g.prints()
 del _g, _Gfloats, _f, _f2
 
 # **) MIT License

pygeodesy/geodesicx/_C4_27.py

@@ -13,7 +13,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 from pygeodesy.geodesicx.gxbases import _Gfloats, _f, _f2
 
 __all__ = ()
-__version__ = '23.08.19'
+__version__ = '24.09.04'
 
 _g = _Gfloats(27)
 _coeffs_27 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 27
@@ -2368,8 +2368,6 @@ _coeffs_27 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 27
     # C4[26], coeff of eps^26, polynomial in n of order 0
     _f(1 << 48), _f2(2126, 0x8c0e9e949456f),  # PYCHOK exported
 ))  # 4032 / 3764
-if __name__ == '__main__':
-    _g.prints()
 del _g, _Gfloats, _f, _f2
 
 # **) MIT License

pygeodesy/geodesicx/_C4_30.py

@@ -30,7 +30,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 from pygeodesy.geodesicx.gxbases import _Gfloats, _f, _f2
 
 __all__ = ()
-__version__ = '23.08.19'
+__version__ = '24.09.04'
 
 _g = _Gfloats(30)
 _coeffs_30 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 30
@@ -3273,8 +3273,6 @@ _coeffs_30 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 30
     # C4[29], coeff of eps^29, polynomial in n of order 0
     _f(1 << 53), _f2(88602, 0xec373d36a45df),  # PYCHOK exported
 ))  # 5425 / 5107
-if __name__ == '__main__':
-    _g.prints()
 del _g, _Gfloats, _f, _f2
 
 

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__ = '24.07.09'
+__version__ = '24.09.06'
 
 # **) MIT License
 #

pygeodesy/geodesicx/__main__.py

@@ -5,65 +5,63 @@ u'''Print L{geodesicx} version, etc. using C{python -m pygeodesy.geodesicx}.
 '''
 
 __all__ = ()
-__version__ = '24.05.31'
+__version__ = '24.09.06'
 
 
-def _C4stats(nC4=None):  # PYCHOK no cover
-    '''(INTERNAL) Get the C{C4} stats.
-    '''
-    from pygeodesy import GeodesicExact, geodesicx
-
-    gX = GeodesicExact(C4order=nC4)
-    cs = geodesicx.gx._C4coeffs(gX.C4order)
-    ss = set(cs)  # without duplicates
-    pc = '%.1f%%' % (len(ss) * 100.0 / len(cs))
-    cx = gX._C4x
-    return dict(C4order=gX.C4order, C4len=len(cs), C4set=len(ss), C4set_len=pc, C4x=len(cx))
-
-
-def _main():  # PYCHOK no cover
-
-    import os.path as os_path
+def _main(**C4order):  # PYCHOK no cover
 
     try:
-        from pygeodesy import geodesicx as _gx, GeodesicError, \
-                              GeodesicSolve, printf, pygeodesy_abspath
-        from pygeodesy.internals import _Pythonarchine, _usage
-        from pygeodesy.interns import _COMMASPACE_, _DOT_, _SPACE_, _version_
-        from pygeodesy.streprs import Fmt
-
-        def _dot_attr(name, value):
-            return Fmt.DOT(Fmt.EQUAL(name, value))
-
-        s = tuple(sorted(_C4stats().items()))
-        p = [_dot_attr(*t) for t in (((_version_, _gx.__version__),) + s)]
-
-        def _name_version(pkg):
-            return _SPACE_(pkg.__name__, pkg.__version__)
-
-        v = _Pythonarchine()
+        from pygeodesy import GeodesicExact, geodesicx
+        from pygeodesy.internals import _fper, _name_version, \
+                                         printf, _sizeof, _versions
+        from pygeodesy.interns import _COMMASPACE_, _EQUAL_
         try:
-            import geographiclib
-            v.append(_name_version(geographiclib))
+            import numpy
         except ImportError:
-            pass
+            numpy = None
+
+        gX = GeodesicExact(**C4order)
+        cs = geodesicx.gx._C4coeffs(gX.C4order)
+        n  = len(cs)
+        u  = n         if numpy else len(set(cs))
+        z  = cs.nbytes if numpy else _sizeof(cs)
+        p  = dict(C4order=gX.C4order, C4n=n, C4u=u,
+                  C4u_n=_fper(u, n), C4x=len(gX._C4x),
+                  C4t=type(cs).__name__, C4z=z)
+        p  = list(_EQUAL_(*t) for t in p.items())
+        if numpy:
+            p.append(_name_version(numpy))
         try:
-            g = GeodesicSolve()
-            v.append(g.version)
-        except GeodesicError:
+            import geographiclib
+            p.append(_name_version(geographiclib))
+        except ImportError:
             pass
 
-        g = _gx.__name__
-        x =  os_path.basename(pygeodesy_abspath)
-        if not g.startswith(x):
-            g = _DOT_(x, g)
-        printf('%s%s (%s)', g, _COMMASPACE_.join(p), _COMMASPACE_.join(v))
+        g = _name_version(geodesicx)
+        printf('%s: %s (%s)', g, _COMMASPACE_.join(p), _versions())
 
     except ImportError:
-        printf(_usage(__file__))
+        from pygeodesy.internals import _usage
+        print(_usage(__file__))
+
+
+from sys import argv  # .internals._isPyChecker
+_main(C4order=int(argv[1])) if len(argv) == 2 and argv[1].isdigit() else _main()
+
+# % python3.13 -m pygeodesy.geodesicx 30
+# pygeodesy.geodesicx 24.09.06: C4order=30, C4n=5425, C4u=5107, C4u_n=94.1%, C4x=465, C4t=tuple, C4z=166008 (pygeodesy 24.9.6 Python 3.13.0rc1 64bit arm64 macOS 14.6.1)
+# % python3.12 -m pygeodesy.geodesicx 30
+# pygeodesy.geodesicx 24.09.06: C4order=30, C4n=5425, C4u=5425, C4u_n=100.0%, C4x=465, C4t=ndarray, C4z=43400, numpy 2.1.0, geographiclib 2.0 (pygeodesy 24.9.6 Python 3.12.5 64bit arm64 macOS 14.6.1)
 
+# % python3.13 -m pygeodesy.geodesicx 27
+# pygeodesy.geodesicx 24.09.06: C4order=27, C4n=4032, C4u=3764, C4u_n=93.4%, C4x=378, C4t=tuple, C4z=122632 (pygeodesy 24.9.6 Python 3.13.0rc1 64bit arm64 macOS 14.6.1)
+# % python3.12 -m pygeodesy.geodesicx 27
+# pygeodesy.geodesicx 24.09.06: C4order=27, C4n=4032, C4u=4032, C4u_n=100.0%, C4x=378, C4t=ndarray, C4z=32256, numpy 2.1.0, geographiclib 2.0 (pygeodesy 24.9.6 Python 3.12.5 64bit arm64 macOS 14.6.1)
 
-_main()
+# % python3.13 -m pygeodesy.geodesicx 24
+# pygeodesy.geodesicx 24.09.06: C4order=24, C4n=2900, C4u=2708, C4u_n=93.4%, C4x=300, C4t=tuple, C4z=88232 (pygeodesy 24.9.6 Python 3.13.0rc1 64bit arm64 macOS 14.6.1)
+# % python3.12 -m pygeodesy.geodesicx 24
+# pygeodesy.geodesicx 24.09.06: C4order=24, C4n=2900, C4u=2900, C4u_n=100.0%, C4x=300, C4t=ndarray, C4z=23200, numpy 2.1.0, geographiclib 2.0 (pygeodesy 24.9.6 Python 3.12.5 64bit arm64 macOS 14.6.1)
 
 # **) MIT License
 #

pygeodesy/geodesicx/gxarea.py

@@ -21,7 +21,7 @@ from pygeodesy.basics import isodd, unsigned0
 from pygeodesy.constants import NAN, _0_0, _0_5, _720_0
 # from pygeodesy.interns import _COMMASPACE_  # from .lazily
 from pygeodesy.karney import Area3Tuple, _diff182, GeodesicError, \
-                            _norm180, _remainder, _sum2_
+                            _norm180, _remainder, _sum3
 from pygeodesy.lazily import _ALL_DOCS, printf,  _COMMASPACE_
 from pygeodesy.named import ADict, callername, _NamedBase,  pairs
 from pygeodesy.props import Property, Property_RO, property_RO
@@ -30,7 +30,7 @@ from pygeodesy.props import Property, Property_RO, property_RO
 from math import fmod as _fmod
 
 __all__ = ()
-__version__ = '24.08.13'
+__version__ = '24.09.04'
 
 
 class GeodesicAreaExact(_NamedBase):
@@ -451,7 +451,7 @@ class _Accumulator(_NamedBase):
            @return: Current C{sum}.
         '''
         self._n += 1
-        self._s, self._t = _sum2_(self._s, self._t, y)
+        self._s, self._t, _ = _sum3(self._s, self._t, y)
         return self._s  # current .Sum()
 
     def Negate(self):

pygeodesy/geodesicx/gxbases.py

@@ -9,17 +9,18 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 '''
 
 from pygeodesy.basics import isodd,  _MODS
-from pygeodesy.constants import _EPSmin as _TINY, _0_0, _100_0
+from pygeodesy.constants import _EPSmin as _TINY, _0_0
 from pygeodesy.errors import _or, _xkwds_item2
 from pygeodesy.fmath import hypot as _hypot
+# from pygeodesy.interns import _numpy_  # _MODS
 from pygeodesy.karney import _CapsBase, GeodesicError, _2cos2x, \
-                             _norm2, _sincos2d, _sum2_
-# from pygeodesy.lazily import _MODS, printf  # .basics, _MODS
+                             _norm2, _sincos2d, _sum3
+# from pygeodesy.lazily import _ALL_MODS as _MODS  # from .basics
 
 from math import fabs, ldexp as _ldexp
 
 __all__ = ()
-__version__ = '24.06.16'
+__version__ = '24.09.07'
 
 # valid C{nC4}s and C{C4order}s, see _xnC4 below
 _nC4s = {24: 2900, 27: 4032, 30: 5425}
@@ -44,7 +45,7 @@ class _GeodesicBase(_CapsBase):  # in .geodsolve
 
 
 class _Gfloats(dict):
-    '''(INTERNAL) Uniquify floats.
+    '''(INTERNAL) Numpy or "Unique" floats.
     '''
     n   = 0  # total number of floats
     nC4 = 0
@@ -53,16 +54,16 @@ class _Gfloats(dict):
         self.nC4 = nC4
 
     def __call__(self, fs):
-        '''Return a tuple of "uniquified" floats.
+        '''Return a C{numpy.array} or C{tuple} of C{float}s.
         '''
+        np = _MODS.imported(_MODS.interns._numpy_)
+        if np:  # use numpy, already imported
+            cs = np.array(fs, dtype=float)
+        else:
+            _f = self.setdefault  # avoid duplicates
+            cs = tuple(_f(f, f) for f in map(float, fs))  # PYCHOK as attr
         self.n += len(fs)
-        _f = self.setdefault
-        return tuple(_f(f, f) for f in map(float, fs))  # PYCHOK as attr
-
-    def prints(self):
-        n, u = self.n, len(self.keys())
-        d = (n - u) * _100_0 / n
-        _MODS.lazily.printf('_CX_%d: n=%d, u=%d, d=%.1f%%', self.nC4, n, u, d)  # XXX
+        return cs
 
 
 def _cosSeries(c4s, sx, cx):  # PYCHOK shared .geodesicx.gx and -.gxline
@@ -75,15 +76,28 @@ def _cosSeries(c4s, sx, cx):  # PYCHOK shared .geodesicx.gx and -.gxline
     _c4 =  c4.pop
     if isodd(len(c4)):
         y0 = _c4()
-    _s2 = _sum2_
     while c4:
         # y1 = ar * y0 - y1 + c4.pop()
         # y0 = ar * y1 - y0 + c4.pop()
-        y1, t1 = _s2(ar * y0, ar * t0, -y1, -t1, _c4())
-        y0, t0 = _s2(ar * y1, ar * t1, -y0, -t0, _c4())
+        y1, t1, _ = _sum3(-y1, -t1, ar * y0, ar * t0, _c4())
+        y0, t0, _ = _sum3(-y0, -t0, ar * y1, ar * t1, _c4())
     # s  = (y0 - y1) * cx
-    s, _ = _s2(cx * y0, _0_0, cx * t0, -cx * y1, -cx * t1)
-    return s
+    s, t, _ = _sum3(cx * y0, _0_0, cx * t0, -cx * y1, -cx * t1)
+    return s + t
+
+#   Y0, Y1 = Fsum(), Fsum()
+#   ar  = _2cos2x(cx, sx)
+#   c4  =  list(c4s)
+#   _c4 =  c4.pop
+#   if isodd(len(c4)):
+#       Y0 += _c4()
+#   while c4:
+#       # y1 = ar * y0 - y1 + c4.pop()
+#       # y0 = ar * y1 - y0 + c4.pop()
+#       Y1 = Y0 * ar - Y1 + _c4()
+#       Y0 = Y1 * ar - Y0 + _c4()
+#   # s  = (y0 - y1) * cx
+#   return float((Y0 - Y1) * cx)
 
 
 _f = float  # in _f2 and .geodesicx._C4_24, _27 and _30