pygeodesy 24.4.18__py2.py3-none-any.whl → 24.4.24__py2.py3-none-any.whl

{PyGeodesy-24.4.18.dist-info → PyGeodesy-24.4.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyGeodesy
-Version: 24.4.18
+Version: 24.4.24
 Summary: Pure Python geodesy tools
 Home-page: https://GitHub.com/mrJean1/PyGeodesy
 Author: Jean M. Brouwers
@@ -158,7 +158,7 @@ and McCabe_ using Python 2.7.18 and with Flake8_ using Python 3.11.5, both in 64
 
 For a summary of all *Karney*-based functionality in ``pygeodesy``, see module karney_.
 
-*Last updated: April 18, 2024.*
+*Last updated: April 24, 2024.*
 
 License
 =======

{PyGeodesy-24.4.18.dist-info → PyGeodesy-24.4.24.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pygeodesy/LICENSE,sha256=YfgAiyxOwY6P9Kkb1_5XN81nueTLrpb3Ffkv3EuPgFU,1144
-pygeodesy/__init__.py,sha256=Wx1Zo8hUxl6CV1eZZvLbrQSQ6VSB8mHBTmPqxcG0Mpc,40824
+pygeodesy/__init__.py,sha256=td1SZErPJBK8oIAHrj4sVvK-n3PjnJbckJQjWhyNHf0,40824
 pygeodesy/__main__.py,sha256=qMFG3caY8ZXWu6uGiemzyT4OqTFZnsFtlxcGCAgkVJw,4637
 pygeodesy/albers.py,sha256=g2AVlpV8JO2AYFCthoIbRC2h1OJqjb9P3hpwF0C3TI8,30994
 pygeodesy/azimuthal.py,sha256=tc4JxgLi-0jzU08m4Bvi-t-kzHXYPeGuzL3j_tyVFUA,50125
@@ -7,7 +7,7 @@ pygeodesy/basics.py,sha256=_BMYLzGKA6OIS3qv25HfHy7MIh0kAbmkzyScb59clUs,28160
 pygeodesy/booleans.py,sha256=HZbwoL-S7Ww9d4C2D1BVqXfmcuqqVpEVSU9_S0uyUyo,74204
 pygeodesy/cartesianBase.py,sha256=I3q29mRdBB3NCDmPoJsJ0QOFfLzkdMWc8X9zG4IwJyA,47264
 pygeodesy/clipy.py,sha256=VU3ynQ1IZ0v5hJlicqD48oW0imRgiL5_ZzRPrIjpfPw,27683
-pygeodesy/constants.py,sha256=ypxYsWB6tNAVgrD9QVpukJAPscaLgHtPLqPuot1gUfU,19174
+pygeodesy/constants.py,sha256=RxO8dMe_3AEfmZyKaRIy_44QnOTdEpzgYwimN0_w9Qs,19113
 pygeodesy/css.py,sha256=sKXsahUiyruDcUk-tGjA6mxq-xzwBoBKxKo9_b2uBmY,25394
 pygeodesy/datums.py,sha256=gJZPgV4bELZvZ8Sj2zE3MBysVtsLxqsN8zm0xjOKvpo,33851
 pygeodesy/dms.py,sha256=op3MU-59CoJQRdybnu21aVM9wtocd_-XFNAZFqmozSo,44439
@@ -25,11 +25,11 @@ pygeodesy/elliptic.py,sha256=XRVpmpdm3hbztM4P-qhWKQizbgsXDUxWujgmOrIpgiQ,42428
 pygeodesy/epsg.py,sha256=ldHoLWqJWR4FUiBVnDTtrI_e7TNjjtr9OkxDlri1g5E,8165
 pygeodesy/errors.py,sha256=mUaacHJKcSCowlcbzamaBMDqjI2dqsTM5O4ozIITtAk,27233
 pygeodesy/etm.py,sha256=joEhU2lw9ehRv101nRpZvXq8hOYAEzdcYFpif9_obfk,44585
-pygeodesy/fmath.py,sha256=9jjm_QxrQKNtOUxgNk02j-UVMFVjC1cDPaEqXznKgzk,30716
+pygeodesy/fmath.py,sha256=cRisVRkuarEwu4pKOCWmBa-98lV2PP9oJVkkODQLc2E,32480
 pygeodesy/formy.py,sha256=Rces4Q5ecED0WVfuI9mQzeyHE54LDowYfI6faBHpyeA,74536
 pygeodesy/frechet.py,sha256=qgee-ISBtT7Ov3rJkcd_t-WeXTbeNoMSQuMa0j3MyQc,33512
 pygeodesy/fstats.py,sha256=r8O2aIknHuoHsW8gZUIY42zpHZy7syHvCB7uCVtPpkc,25559
-pygeodesy/fsums.py,sha256=QjV9B-YGbhFALMPEQMKT8-1j7JFDWnabakAdZDvFsSs,72501
+pygeodesy/fsums.py,sha256=Am8CRdltomItdCpdBUDyc1xP53KmrCXXs9rBTa19hs4,73370
 pygeodesy/gars.py,sha256=fCiWBJ4kOJxPfNOxadX-OzBGDXj7C9g02NuGHiZa_88,11342
 pygeodesy/geodesicw.py,sha256=5yjJ2rLekSsjT7e-Km6v592ZcFlA41flQP_E42jU9Sw,26901
 pygeodesy/geodsolve.py,sha256=3GLI2_4gglzTpZwKchNzAv-XhWFBzWRKjcWsjCC3dvI,21900
@@ -42,7 +42,7 @@ pygeodesy/iters.py,sha256=CfU365eE9F4oWZbBx0qTEvfodMhpa8rGOepLIv67xF8,20181
 pygeodesy/karney.py,sha256=lYdsSHis8xQJVS1V0F3cphx6Dhgd77xTlMOdVR8MN8I,34994
 pygeodesy/ktm.py,sha256=sCvbLvJItavlruilAyjeZ0sOZx2yJumzGe_UiIVbGi4,27315
 pygeodesy/latlonBase.py,sha256=LimCMj91J3Q4D_rTu7VN7c63cLL_KzxXagFQfedobmc,77730
-pygeodesy/lazily.py,sha256=4ZxBVj1Yu4Db-dw_e6oxXx7EtDSrgdGBV-ypUefMPGY,48633
+pygeodesy/lazily.py,sha256=YeOQQ2Tu0LTD-AMDABc0bemeLRKTteTEJXJDl3_7vZU,48645
 pygeodesy/lcc.py,sha256=yNpmAdOwv3HNh2ZLopF5QtvDokeQYCmnxSc8UFUPHO4,25737
 pygeodesy/ltp.py,sha256=8se8dYG7LG__Ru0FoK939DJBF9GCQGeJik_Un1Im8Xw,48609
 pygeodesy/ltpTuples.py,sha256=iKzvDfv33HfmEevjNISUS4c9KXIkiISEkVlQopyKgfY,55769
@@ -109,7 +109,7 @@ pygeodesy/rhumb/aux_.py,sha256=W4HkgoHAQz_aWaysfsmOA5010nCGvBfUs2Q-bymnHYU,16660
 pygeodesy/rhumb/bases.py,sha256=kzU_Dgt4FNPMgTg5rqbw-HiNpflDPKpmq9jhPbQmR4U,53851
 pygeodesy/rhumb/ekx.py,sha256=lF3tZ-ZY9fPJV8y1kgHW-7EOZCyb3gJr-kR-jj5Fbf8,23871
 pygeodesy/rhumb/solve.py,sha256=NZfwx7xv5UriQs7A0c7ZhoxxVUeAT15UwXK_jtwEXQw,27802
-PyGeodesy-24.4.18.dist-info/METADATA,sha256=kwVbSazBaM7cCqqiNZ0-SQbbnG7-Y3vLtmAh_yGMK3s,19366
-PyGeodesy-24.4.18.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
-PyGeodesy-24.4.18.dist-info/top_level.txt,sha256=cEQPatCXzKZqrivpULC5V5fuy9_V_bAwaP_gUGid7pQ,10
-PyGeodesy-24.4.18.dist-info/RECORD,,
+PyGeodesy-24.4.24.dist-info/METADATA,sha256=IGu3-2Wu7HfzR8MYGeOU_oWysKdkDfMkndw45lFqWvY,19366
+PyGeodesy-24.4.24.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
+PyGeodesy-24.4.24.dist-info/top_level.txt,sha256=cEQPatCXzKZqrivpULC5V5fuy9_V_bAwaP_gUGid7pQ,10
+PyGeodesy-24.4.24.dist-info/RECORD,,

pygeodesy/__init__.py

@@ -586,7 +586,7 @@ else:
     _init__all__ = False
 
 from pygeodesy.interns import _DOT_, _version2  # PYCHOK import
-__version__ = '24.04.18'
+__version__ = '24.04.24'
 # see setup.py for similar logic
 version     = _DOT_(*_version2(__version__, n=3))
 

pygeodesy/constants.py

@@ -23,7 +23,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '24.04.04'
+__version__ = '24.04.23'
 
 
 def _copysign_0_0(y):
@@ -247,7 +247,6 @@ _1_16th  = _Float(_1_16th =_1_0 / _16_0)  # PYCHOK in .ellipsoids, .karney
 _1_64th  = _Float(_1_64th =_1_0 /  64)    # PYCHOK in .elliptic, pow(2.0, -6)
 _1_3rd   = _Float(_1_3rd  =_1_0 /  _3_0)  # PYCHOK in .fmath
 _1_6th   = _Float(_1_6th  =_1_0 /  _6_0)  # PYCHOK in .fmath
-_2_3rd   = _Float(_2_3rd  =_2_0 /  _3_0)  # PYCHOK in .fmath
 
 _K0_UTM  = _Float(_K0_UTM = 0.9996)  # PYCHOK in .etm, .ktm, .utm, UTM scale at central meridian
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>

pygeodesy/fmath.py

@@ -6,17 +6,14 @@ u'''Utilities using precision floating point summation.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _copysign, copysign0, isint, len2
+from pygeodesy.basics import _copysign, copysign0, isbool, isint, isscalar, len2
 from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
-                               _0_0, _0_125, _0_25, _0_5, _1_0, _1_3rd, \
-                               _1_5, _1_6th, _2_0, _2_3rd, _3_0, \
-                               _copysign_0_0, _isfinite, _over, remainder
+                               _0_0, _0_125, _1_6th, _0_25, _1_3rd, _0_5, _1_0, \
+                               _1_5, _copysign_0_0, _isfinite, _over, remainder
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
                              _xError, _xkwds_get, _xkwds_pop2
-from pygeodesy.fsums import _2float, Fsum, _fsum, fsum, fsum1_, _1primed, \
-                             Fmt, unstr
-from pygeodesy.interns import MISSING, _few_, _h_, _invokation_, _negative_, \
-                             _not_scalar_, _SPACE_, _too_
+from pygeodesy.fsums import _2float, Fsum, fsum, fsum1_, _1primed,  Fmt, unstr
+from pygeodesy.interns import MISSING, _few_, _negative_, _not_scalar_, _too_
 from pygeodesy.lazily import _ALL_LAZY, _sys_version_info2
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
 from pygeodesy.units import Int_, _isHeight, _isRadius,  Float_  # PYCHOK for .heights
@@ -25,21 +22,14 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '24.04.17'
+__version__ = '24.04.24'
 
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ... sqrt(2) - 1
+_2_3rd   = _1_3rd * 2
 _h_lt_b_ = 'abs(h) < abs(b)'
 
 
-def _Fsum__init__(inst, raiser=MISSING, **name_RESIDUAL):
-    '''(INTERNAL) Init an C{Fsum} instance.
-    '''
-    Fsum.__init__(inst, **name_RESIDUAL)  # PYCHOK self
-    inst._fset_ps(_0_0)
-    return {} if raiser is MISSING else dict(raiser=raiser)
-
-
 class Fdot(Fsum):
     '''Precision dot product.
     '''
@@ -104,7 +94,7 @@ class Fhorner(Fsum):
 
 
 class Fhypot(Fsum):
-    '''Precision summation and hypotenuse, default C{power=2}.
+    '''Precision summation and hypotenuse, default C{root=2}.
     '''
     def __init__(self, *xs, **root_name_RESIDUAL_raiser):
         '''New L{Fhypot} hypotenuse of (the I{root} of) several components.
@@ -189,7 +179,7 @@ class Froot(Fsum):
         try:
             raiser = _Fsum__init__(self, **name_RESIDUAL_raiser)
             if xs:
-                self. fadd(xs)
+                self.fadd(xs)
             self._fset(self.root(root, **raiser))
         except Exception as X:
             raise self._ErrorXs(X, xs, root=root)
@@ -203,7 +193,7 @@ class Fcbrt(Froot):
 
            @see: Class L{Froot} for further details.
         '''
-        Froot.__init__(self, _3_0, *xs, **name_RESIDUAL_raiser)
+        Froot.__init__(self, 3, *xs, **name_RESIDUAL_raiser)
 
 
 class Fsqrt(Froot):
@@ -214,15 +204,24 @@ class Fsqrt(Froot):
 
            @see: Class L{Froot} for further details.
         '''
-        Froot.__init__(self, _2_0, *xs, **name_RESIDUAL_raiser)
+        Froot.__init__(self, 2, *xs, **name_RESIDUAL_raiser)
+
+
+def _Fsum__init__(inst, raiser=MISSING, **name_RESIDUAL):
+    '''(INTERNAL) Init an C{F...} instance above.
+    '''
+    Fsum.__init__(inst, **name_RESIDUAL)  # PYCHOK self
+    inst._fset_ps(_0_0)
+    return {} if raiser is MISSING else dict(raiser=raiser)
 
 
 def bqrt(x):
-    '''Return the 4-th, I{bi-quadratic} or I{quartic} root, M{x**(1 / 4)}.
+    '''Return the 4-th, I{bi-quadratic} or I{quartic} root, M{x**(1 / 4)},
+       preserving C{type(B{x})}.
 
-       @arg x: Value (C{scalar}).
+       @arg x: Value (C{scalar} or L{Fsum} instance).
 
-       @return: I{Quartic} root (C{float}).
+       @return: I{Quartic} root (C{float} or L{Fsum}).
 
        @raise ValueError: Negative B{C{x}}.
 
@@ -232,70 +231,76 @@ def bqrt(x):
 
 
 try:
-    from math import cbrt  # Python 3.11+
-
-    def cbrt2(x):
-        '''Compute the cube root I{squared} M{x**(2/3)}.
-        '''
-        return cbrt(x)**2  # cbrt(-0.0*2) == -0.0
+    from math import cbrt as _cbrt  # Python 3.11+
 
 except ImportError:  # Python 3.10-
 
-    def cbrt(x):
-        '''Compute the cube root M{x**(1/3)}.
-
-           @arg x: Value (C{scalar}).
-
-           @return: Cubic root (C{float}).
-
-           @see: Functions L{cbrt2} and L{sqrt3}.
+    def _cbrt(x):
+        '''(INTERNAL) Compute the I{signed}, cube root M{x**(1/3)}.
         '''
         # <https://archive.lib.MSU.edu/crcmath/math/math/r/r021.htm>
         # simpler and more accurate than Ken Turkowski's CubeRoot, see
         # <https://People.FreeBSD.org/~lstewart/references/apple_tr_kt32_cuberoot.pdf>
-        return _copysign(pow(fabs(x), _1_3rd), x)  # cbrt(-0.0) == -0.0
+        return _copysign(pow(fabs(x), _1_3rd), x)  # to avoid complex
 
-    def cbrt2(x):  # PYCHOK attr
-        '''Compute the cube root I{squared} M{x**(2/3)}.
 
-           @arg x: Value (C{scalar}).
+def cbrt(x):
+    '''Compute the cube root M{x**(1/3)}, preserving C{type(B{x})}.
 
-           @return: Cube root I{squared} (C{float}).
+       @arg x: Value (C{scalar} or L{Fsum} instance).
 
-           @see: Functions L{cbrt} and L{sqrt3}.
-        '''
-        return pow(fabs(x), _2_3rd)  # XXX pow(fabs(x), _1_3rd)**2
+       @return: Cubic root (C{float} or L{Fsum}).
+
+       @see: Functions L{cbrt2} and L{sqrt3}.
+    '''
+    if isinstance(x, Fsum):
+        r = (-(-x).pow(_1_3rd)) if x < 0 else x.pow(_1_3rd)
+    else:
+        r = _cbrt(x)
+    return r  # cbrt(-0.0) == -0.0
+
+
+def cbrt2(x):  # PYCHOK attr
+    '''Compute the cube root I{squared} M{x**(2/3)}, preserving C{type(B{x})}.
+
+       @arg x: Value (C{scalar} or L{Fsum} instance).
+
+       @return: Cube root I{squared} (C{float} or L{Fsum}).
+
+       @see: Functions L{cbrt} and L{sqrt3}.
+    '''
+    return abs(x).pow(_2_3rd) if isinstance(x, Fsum) else _cbrt(x**2)
 
 
 def euclid(x, y):
     '''I{Appoximate} the norm M{sqrt(x**2 + y**2)} by
        M{max(abs(x), abs(y)) + min(abs(x), abs(y)) * 0.4142...}.
 
-       @arg x: X component (C{scalar}).
-       @arg y: Y component (C{scalar}).
+       @arg x: X component (C{scalar} or L{Fsum} instance).
+       @arg y: Y component (C{scalar} or L{Fsum} instance).
 
-       @return: Appoximate norm (C{float}).
+       @return: Appoximate norm (C{float} or L{Fsum}).
 
        @see: Function L{euclid_}.
     '''
-    x, y = fabs(x), fabs(y)
+    x, y = abs(x), abs(y)  # NOT fabs!
     if x < y:
         x, y = y, x
     return x + y * _0_4142  # XXX * _0_5 before 20.10.02
 
 
 def euclid_(*xs):
-    '''I{Appoximate} the norm M{sqrt(sum(x**2 for x in xs))}
-       by cascaded L{euclid}.
+    '''I{Appoximate} the norm M{sqrt(sum(x**2 for x in xs))} by
+       cascaded L{euclid}.
 
-       @arg xs: X arguments, positional (C{scalar}s).
+       @arg xs: X arguments, positional (C{scalar}s or L{Fsum} instances).
 
-       @return: Appoximate norm (C{float}).
+       @return: Appoximate norm (C{float} or L{Fsum}).
 
        @see: Function L{euclid}.
     '''
     e = _0_0
-    for x in sorted(map(fabs, xs)):  # XXX not reverse=True
+    for x in sorted(map(abs, xs)):  # NOT fabs, reverse=True!
         # e = euclid(x, e)
         if e < x:
             e, x = x, e
@@ -388,8 +393,8 @@ def fatan2(y, x):
 def favg(v1, v2, f=_0_5):
     '''Return the average of two values.
 
-       @arg v1: One value (C{scalar}).
-       @arg v2: Other value (C{scalar}).
+       @arg v1: One value (C{scalar} or L{Fsum} instance).
+       @arg v2: Other value (C{scalar} or L{Fsum} instance).
        @kwarg f: Optional fraction (C{float}).
 
        @return: M{v1 + f * (v2 - v1)} (C{float}).
@@ -606,6 +611,39 @@ except ImportError:
         return freduce(_operator.mul, xs, start)
 
 
+def frandoms(n, seeded=None):
+    '''Generate C{n} (long) lists of random C{floats}.
+
+       @arg n: Number of lists to generate (C{int}, non-negative).
+       @kwarg seeded: If C{scalar}, use C{random.seed(B{seeded})} or
+                      if C{True}, seed using today's C{year-day}.
+
+       @see: U{Hettinger<https://GitHub.com/ActiveState/code/tree/master/recipes/
+             Python/393090_Binary_floating_point_summatiaccurate_full/recipe-393090.py>}.
+    '''
+    from random import gauss, random, seed, shuffle
+
+    if seeded is None:
+        pass
+    elif seeded and isbool(seeded):
+        from time import localtime
+        seed(localtime().tm_yday)
+    elif isscalar(seeded):
+        seed(seeded)
+
+    c = (7, 1e100, -7, -1e100, -9e-20, 8e-20) * 7
+    for _ in range(n):
+        s  = 0
+        t  = list(c)
+        _a = t.append
+        for _ in range(n * 8):
+            v = gauss(0, random())**7 - s
+            _a(v)
+            s += v
+        shuffle(t)
+        yield t
+
+
 def frange(start, number, step=1):
     '''Generate a range of C{float}s.
 
@@ -715,8 +753,8 @@ if _sys_version_info2 < (3, 8):  # PYCHOK no cover
                   computed as M{hypot_(*((c1 - c2) for c1, c2 in zip(p1, p2)))},
                   provided I{p1} and I{p2} have the same, non-zero length I{n}.
         '''
-        h, x2 = _h_x2(xs, hypot_)
-        return (h * sqrt(x2)) if x2 else _0_0
+        _, R = _h_xs2(xs, True, hypot_)
+        return float(R)
 
 elif _sys_version_info2 < (3, 10):
     # In Python 3.8 and 3.9 C{math.hypot} is inaccurate, see
@@ -732,13 +770,8 @@ elif _sys_version_info2 < (3, 10):
 
            @return: C{sqrt(B{x}**2 + B{y}**2)} (C{float}).
         '''
-        if x:
-            h = sqrt(x**2 + y**2) if y else fabs(x)
-        elif y:
-            h = fabs(y)
-        else:
-            h = _0_0
-        return h
+        return (float(Fhypot(x, y, raiser=False)) if y else
+                fabs(x)) if x else fabs(y)
 
     from math import hypot as hypot_  # PYCHOK in Python 3.8 and 3.9
 else:
@@ -746,29 +779,32 @@ else:
     hypot_ = hypot
 
 
-def _h_x2(xs, which):
+def _h_xs2(xs, pot_, which):
     '''(INTERNAL) Helper for L{hypot_} and L{hypot2_}.
     '''
     n, xs = len2(xs)
     if n > 0:
-        h = float(max(map(fabs, xs)))
+        h = float(max(map(abs, xs)))  # NOT fabs!
         if h < EPS0:
-            x2 = _0_0
+            R = _0_0
         elif n > 1:
-            _h = (_1_0 / h) if h != _1_0 else _1_0
-            x2 = _fsum(_1primed((x * _h)**2 for x in xs))
+            if pot_:
+                if h != _1_0:
+                    xs = ((x / h) for x in xs)
+                R = Fhypot(*xs, raiser=False) * h
+            else:
+                R = Fpowers(2, *xs)
         else:
-            x2 = _1_0
-        return h, x2
+            R = h if pot_ else (h**2)
+        return h, R
 
-    t = Fmt.PAREN(which.__name__, xs)
-    raise _ValueError(t, txt=_too_(_few_))
+    raise _ValueError(unstr(which, xs), txt=_too_(_few_))
 
 
 def hypot1(x):
     '''Compute the norm M{sqrt(1 + x**2)}.
 
-       @arg x: Argument (C{scalar}).
+       @arg x: Argument (C{scalar} or L{Fsum} instance).
 
        @return: Norm (C{float}).
     '''
@@ -778,12 +814,12 @@ def hypot1(x):
 def hypot2(x, y):
     '''Compute the I{squared} norm M{x**2 + y**2}.
 
-       @arg x: X argument (C{scalar}).
-       @arg y: Y argument (C{scalar}).
+       @arg x: X argument (C{scalar} or L{Fsum} instance).
+       @arg y: Y argument (C{scalar} or L{Fsum} instance).
 
-       @return: C{B{x}**2 + B{y}**2} (C{float}).
+       @return: C{B{x}**2 + B{y}**2} (C{float} or L{Fsum}).
     '''
-    if fabs(x) < fabs(y):
+    if abs(x) < abs(y):  # NOT fabs!
         x, y = y, x
     if x:
         h2 = x**2
@@ -795,9 +831,10 @@ def hypot2(x, y):
 
 
 def hypot2_(*xs):
-    '''Compute the I{squared} norm C{sum(x**2 for x in B{xs})}.
+    '''Compute the I{squared} norm C{fsum(x**2 for x in B{xs})}.
 
-       @arg xs: X arguments (C{scalar}s), all positional.
+       @arg xs: X arguments (C{scalar}s or L{Fsum} instances),
+                all positional.
 
        @return: Squared norm (C{float}).
 
@@ -807,8 +844,8 @@ def hypot2_(*xs):
 
        @see: Function L{hypot_}.
     '''
-    h, x2 = _h_x2(xs, hypot2_)
-    return (h**2 * x2) if x2 else _0_0
+    _, R = _h_xs2(xs, False, hypot2_)
+    return float(R)
 
 
 def _map_mul(a, b, where):
@@ -860,12 +897,13 @@ def norm_(*xs):
               or zero norm.
     '''
     try:
+        i  = x = h = None
         h  = hypot_(*xs)
         _h = (_1_0 / h) if h else _0_0
         for i, x in enumerate(xs):
             yield x * _h
-    except Exception as e:
-        raise _xError(e, Fmt.SQUARE(xs=i), x, _h_, h)
+    except Exception as X:
+        raise _xError(X, Fmt.SQUARE(xs=i), x, h=h)
 
 
 def _powers(x, n):
@@ -880,34 +918,40 @@ def _powers(x, n):
 def _root(x, p, where):
     '''(INTERNAL) Raise C{x} to power C{0 < p < 1}.
     '''
-    if x < 0:
-        t = _SPACE_(_invokation_, where.__name__)
-        raise _ValueError(unstr(t, x), txt=_negative_)
-    return pow(x, p) if x else _0_0
+    try:
+        if x > 0:
+            return pow(x, p)
+        elif x < 0:
+            raise ValueError(_negative_)
+    except Exception as X:
+        raise _xError(X, unstr(where, x))
+    return _0_0
 
 
 def sqrt0(x, Error=None):
-    '''Return the square root iff C{B{x} >} L{EPS02}.
+    '''Return the square root C{sqrt(B{x})} iff C{B{x} > }L{EPS02},
+       preserving C{type(B{x})}.
 
-       @arg x: Value (C{scalar}).
+       @arg x: Value (C{scalar} or L{Fsum} instance).
        @kwarg Error: Error to raise for negative B{C{x}}.
 
-       @return: Square root (C{float}) or C{0.0}.
+       @return: Square root (C{float} or L{Fsum}) or C{0.0}.
 
        @note: Any C{B{x} < }L{EPS02} I{including} C{B{x} < 0}
               returns C{0.0}.
     '''
     if Error and x < 0:
-        raise Error(Fmt.PAREN(sqrt=x))
-    return sqrt(x) if x > EPS02 else (_0_0 if x < EPS02 else EPS0)
+        raise Error(unstr(sqrt0, x))
+    return _root(x, _0_5, sqrt0) if x > EPS02 else (_0_0 if x < EPS02 else EPS0)
 
 
 def sqrt3(x):
-    '''Return the square root, I{cubed} M{sqrt(x)**3} or M{sqrt(x**3)}.
+    '''Return the square root, I{cubed} M{sqrt(x)**3} or M{sqrt(x**3)},
+       preserving C{type(B{x})}.
 
-       @arg x: Value (C{scalar}).
+       @arg x: Value (C{scalar} or L{Fsum} instance).
 
-       @return: Square root I{cubed} (C{float}).
+       @return: Square root I{cubed} (C{float} or L{Fsum}).
 
        @raise ValueError: Negative B{C{x}}.
 
@@ -956,11 +1000,12 @@ def sqrt_a(h, b):
 
 
 def zcrt(x):
-    '''Return the 6-th, I{zenzi-cubic} root, M{x**(1 / 6)}.
+    '''Return the 6-th, I{zenzi-cubic} root, M{x**(1 / 6)},
+       preserving C{type(B{x})}.
 
-       @arg x: Value (C{scalar}).
+       @arg x: Value (C{scalar} or L{Fsum} instance).
 
-       @return: I{Zenzi-cubic} root (C{float}).
+       @return: I{Zenzi-cubic} root (C{float} or L{Fsum}).
 
        @see: Functions L{bqrt} and L{zqrt}.
 
@@ -970,11 +1015,12 @@ def zcrt(x):
 
 
 def zqrt(x):
-    '''Return the 8-th, I{zenzi-quartic} or I{squared-quartic} root, M{x**(1 / 8)}.
+    '''Return the 8-th, I{zenzi-quartic} or I{squared-quartic} root,
+       M{x**(1 / 8)}, preserving C{type(B{x})}.
 
-       @arg x: Value (C{scalar}).
+       @arg x: Value (C{scalar} or L{Fsum} instance).
 
-       @return: I{Zenzi-quartic} root (C{float}).
+       @return: I{Zenzi-quartic} root (C{float} or L{Fsum}).
 
        @see: Functions L{bqrt} and L{zcrt}.
 

pygeodesy/fsums.py

@@ -29,8 +29,9 @@ from pygeodesy.basics import iscomplex, isint, isscalar, itemsorted, \
                              signOf, _signOf
 from pygeodesy.constants import INT0, _isfinite, NEG0, _pos_self, \
                                _0_0, _1_0, _N_1_0,  Float, Int
-from pygeodesy.errors import _OverflowError, _TypeError, _ValueError, _xError, \
-                             _xError2, _xkwds_get, _ZeroDivisionError
+from pygeodesy.errors import _AssertionError, _OverflowError, _TypeError, \
+                             _ValueError, _xError, _xError2, _xkwds_get, \
+                             _ZeroDivisionError
 from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DASH_, _DOT_, _EQUAL_, \
                              _exceeds_, _from_, _iadd_op_, _LANGLE_, _negative_, \
                              _NOTEQUAL_, _not_finite_, _PERCENT_, _PLUS_, _R_, \
@@ -45,7 +46,7 @@ from pygeodesy.props import _allPropertiesOf_n, deprecated_property_RO, \
 from math import ceil as _ceil, fabs, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '24.04.18'
+__version__ = '24.04.24'
 
 _add_op_       = _PLUS_  # in .auxilats.auxAngle
 _eq_op_        = _EQUAL_ * 2  # _DEQUAL_
@@ -145,6 +146,12 @@ def _2halfeven(s, r, p):
     return s
 
 
+def _1_over(x, op=_truediv_op_, **raiser):
+    '''(INTERNAL) Return C{Fsum(1) /= B{x}}.
+    '''
+    return _Psum_(_1_0)._ftruediv(x, op, **raiser)
+
+
 def _1primed(xs):  # in .fmath
     '''(INTERNAL) 1-Primed summation of iterable C{xs}
        items, all I{known} to be C{finite float}.
@@ -156,9 +163,11 @@ def _1primed(xs):  # in .fmath
 
 
 def _2ps(s, r):
-    '''(INTERNAL) Return a C{s} and C{r} pair, I{ps-ordered}.
+    '''(INTERNAL) Return an C{s} and C{r} pair, I{ps-ordered}.
     '''
-    return (s, r) if fabs(s) < fabs(r) else (r, s)
+    if fabs(s) < fabs(r):
+        s, r = r, s
+    return (r, s) if r else (s,)  # PYCHOK types
 
 
 def _psum(ps):  # PYCHOK used!
@@ -192,13 +201,10 @@ def _Psum(ps, **name):
     return F
 
 
-def _Psum_1(p=_1_0, **name):
-    '''(INTERNAL) Return an C{Fsum} from a single partial C{p}.
+def _Psum_(*ps, **name):
+    '''(INTERNAL) Return an C{Fsum} from 1 or 2 known scalar(s) C{ps}.
     '''
-    F = Fsum(**name) if name else Fsum()
-    F._ps[:] = p,
-    F._n = 1  # len(F._ps)
-    return F
+    return _Psum(ps, **name)
 
 
 def _2scalar(other, _raiser=None, **mod):
@@ -267,9 +273,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
        @note: Handling of exceptions and C{inf}, C{INF}, C{nan} and C{NAN} differs from
               Python's C{math.fsum}.
 
-       @see: U{Hettinger<https://GitHub.com/ActiveState/code/blob/master/recipes/Python/
-             393090_Binary_floating_point_summatiaccurate_full/recipe-393090.py>}, U{Kahan
-             <https://WikiPedia.org/wiki/Kahan_summation_algorithm>}, U{Klein
+       @see: U{Hettinger<https://GitHub.com/ActiveState/code/tree/master/recipes/Python/
+             393090_Binary_floating_point_summatiaccurate_full/recipe-393090.py>},
+             U{Kahan<https://WikiPedia.org/wiki/Kahan_summation_algorithm>}, U{Klein
              <https://Link.Springer.com/article/10.1007/s00607-005-0139-x>}, Python 2.6+
              file I{Modules/mathmodule.c} and the issue log U{Full precision summation
              <https://Bugs.Python.org/issue2819>}.
@@ -336,8 +342,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         '''
         return self.ceil
 
-    def __cmp__(self, other):  # Python 2-
-        '''Compare this with an other instance or C{scalar}.
+    def __cmp__(self, other):  # PYCHOK no cover
+        '''Compare this with an other instance or C{scalar}, Python 2-.
 
            @return: -1, 0 or +1 (C{int}).
 
@@ -686,8 +692,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
            @arg ndigits: Optional number of digits (C{int}).
         '''
         # <https://docs.Python.org/3.12/reference/datamodel.html?#object.__round__>
-        return _Psum_1(round(float(self), *ndigits),  # can be C{int}
-                       name=self.__round__.__name__)
+        return _Psum_(round(float(self), *ndigits),  # can be C{int}
+                      name=self.__round__.__name__)
 
     def __rpow__(self, other, *mod):
         '''Return C{B{other}**B{self}} as an L{Fsum}.
@@ -771,6 +777,13 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             d = 1
         return n, d
 
+    @property_RO
+    def as_iscalar(self):
+        '''Get this instance I{as-is} (L{Fsum}) or C{scalar} iff scalar.
+        '''
+        s, r = self._fprs2
+        return self if r else s
+
     @property_RO
     def ceil(self):
         '''Get this instance' C{ceil} value (C{int} in Python 3+,
@@ -854,7 +867,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
     def _Error(self, op, other, Error, **txt_cause):
         '''(INTERNAL) Format an B{C{Error}} for C{{self} B{op} B{other}}.
         '''
-        return Error(_SPACE_(self.toStr(), op, other), **txt_cause)
+        return Error(_SPACE_(self.as_iscalar, op, other), **txt_cause)
 
     def _ErrorX(self, X, op, other, *mod):
         '''(INTERNAL) Format the caught exception C{X}.
@@ -875,9 +888,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         '''(INTERNAL) Accumulate more C{scalars} or L{Fsum}s.
         '''
         if xs:
-            _x = _2floats(xs, **origin_X_x)  # PYCHOK yield
-            ps =  self._ps
-            ps[:] = self._ps_acc(list(ps), _x, up=up)
+            _xs   = _2floats(xs, **origin_X_x)  # PYCHOK yield
+            ps    =  self._ps
+            ps[:] =  self._ps_acc(list(ps), _xs, up=up)
         return self
 
     def _facc_1(self, xs, **up):
@@ -907,7 +920,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             r = 0
             if isinstance(p, Fsum):
                 s, r = p._fprs2
-                if r:
+                if r == 0:
                     return _Pow4(s)
                 m = Fsum._pow
             elif isint(p, both=True) and int(p) >= 0:
@@ -922,7 +935,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         if p:  # and xs:
             _pow =  Fsum._pow_2_3
             _Fs  =  Fsum
-            _Ps  = _Psum_1()._fset_ps_
+            _Ps  = _Psum_  # ()._fset_ps_
             op   =  which.__name__
 
             def _X(X):
@@ -1052,24 +1065,28 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         raise ValueError(_not_finite_) if op is None else \
               self._ValueError(op, other, txt=_not_finite_)
 
-    def fint(self, raiser=True, **name):
+    def fint(self, raiser=True, name=NN, **RESIDUAL):
         '''Return this instance' current running sum as C{integer}.
 
            @kwarg raiser: Use C{B{raiser}=False} to ignore L{ResidualError}s
                           (C{bool}), see also method L{RESIDUAL}.
            @kwarg name: Optional name (C{str}), overriding C{"fint"}.
+           @kwarg RESIDUAL: Optional threshold, overriding the current
+                            L{RESIDUAL<Fsum.RESIDUAL>} (C{scalar}).
 
-           @return: The C{integer} (L{Fsum}).
+           @return: The C{integer} sum (L{Fsum}) if this instance
+                    C{is_integer} and the residual is zero or
+                    insignificant or if C{B{raiser}=False}.
 
            @raise ResidualError: Non-zero I{integer} residual.
 
            @see: Methods L{Fsum.int_float} and L{Fsum.is_integer}.
         '''
         i, r = self._fint2
-        if r and raiser:
+        if r and raiser and self._raiser2sum(r, i, **RESIDUAL):
             t = _stresidual(_integer_, r)
             raise ResidualError(_integer_, i, txt=t)
-        f = self._copy_2(self.fint, **name)
+        f = self._copy_2(self.fint, name=name)
         return f._fset(i)
 
     def fint2(self, **name):
@@ -1165,7 +1182,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
                 i, _ = self._fint2  # assert _ == 0
                 x = _2scalar(other)  # C{int}, C{float} or other
                 f =  self._pow_2_3(i, x, other, op, **raiser) if isscalar(x) else \
-                    _Psum_1(i)._pow(  x, other, op, **raiser)  # x is Fsum
+                    _Psum_(i)._pow(   x, other, op, **raiser)  # x is Fsum
             else:  # mod[0] is None, power(self, other)
                 f =  self._pow(other, other, op, **raiser)
         else:  # pow(self, other)
@@ -1250,7 +1267,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             # Property's _fset zaps the value just set by the @setter
             self.__dict__.update(_fint2=t, _fprs=s, _fprs2=Fsum2Tuple(s, INT0))
         else:  # PYCHOK no cover
-            raise self._TypeError(_fset_op_, other)  # AssertionError
+            raise self._Error(_fset_op_, other, _AssertionError)
         return self
 
     def _fset_ps(self, other, n=0):  # in .fmath
@@ -1264,12 +1281,12 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             self._n     = n or 1
         return self
 
-    def _fset_ps_(self, *xs):
-        '''(INTERNAL) Set partials to all known scalar C{xs}.
-        '''
-        self._ps[:] = xs
-        self.n = len(xs)
-        return self
+#   def _fset_ps_(self, *xs):
+#       '''(INTERNAL) Set partials to all known scalar C{xs}.
+#       '''
+#       self._ps[:] = xs
+#       self.n = len(xs)
+#       return self
 
     def fsub(self, xs=()):
         '''Subtract an iterable of C{scalar} or L{Fsum} instances from
@@ -1436,24 +1453,26 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         '''
         return _0_0
 
-    def int_float(self, raiser=False):
+    def int_float(self, raiser=False, **RESIDUAL):
         '''Return this instance' current running sum as C{int} or C{float}.
 
            @kwarg raiser: If C{True} throw a L{ResidualError} if the
-                          residual is non-zero (C{bool}).
+                          residual exceeds the C{RESIDUAL} (C{bool}).
+           @kwarg RESIDUAL: Optional threshold, overriding the current
+                            L{RESIDUAL<Fsum.RESIDUAL>} (C{scalar}).
 
            @return: This C{integer} sum if this instance C{is_integer},
-                    otherwise return the C{float} sum if the residual
-                    is zero or if C{B{raiser}=False}.
+                    otherwise return the C{float} sum if the residual is
+                    zero or insignificant or if C{B{raiser}=False}.
 
            @raise ResidualError: Non-zero residual and C{B{raiser}=True}.
 
-           @see: Methods L{Fsum.fint} and L{Fsum.fint2}.
+           @see: Methods L{Fsum.fint} and L{Fsum.fint2} and property L{Fsum.as_iscalar}.
         '''
         s, r = self._fint2
         if r:
             s, r = self._fprs2
-            if r and raiser:  # PYCHOK no cover
+            if r and raiser and self._raiser2sum(r, s, **RESIDUAL):  # PYCHOK no cover
                 t = _stresidual(_non_zero_, r)
                 raise ResidualError(int_float=s, txt=t)
             s = float(s)  # redundant
@@ -1467,7 +1486,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
     def is_integer(self):
         '''Is this instance' running sum C{integer}? (C{bool}).
 
-           @see: Methods L{Fsum.fint} and L{Fsum.fint2}.
+           @see: Methods L{Fsum.fint}, L{Fsum.fint2} and L{Fsum.is_scalar}.
         '''
         _, r = self._fint2
         return False if r else True
@@ -1486,12 +1505,20 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         f = Fsum._math_fsum
         return 2 if _psum is f else bool(f)
 
+    def is_scalar(self):
+        '''Is this instance' running sum C{scalar}? (C{bool}).
+
+           @see: Method L{Fsum.is_integer} and property L{Fsum.as_iscalar}.
+        '''
+        s, r = t = self._fprs2
+        return False if r and _2sum(s, r) != t else True
+
     def _mul_Fsum(self, other, op=_mul_op_):  # in .fmath.Fhorner
         '''(INTERNAL) Return C{B{self} * Fsum B{other}} as L{Fsum} or C{0}.
         '''
         # assert isinstance(other, Fsum)
         if self._ps and other._ps:
-            f =  self._ps_mul(op, *other._ps)  # NO ._2scalar
+            f =  self._ps_mul(op, *other._ps)  # NO .as_iscalar
         else:
             f = _0_0
         return f
@@ -1503,7 +1530,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         if self._ps and self._finite(factor, op):
             f =  self      if factor == _1_0 else (
                  self._neg if factor == _N_1_0 else
-                 self._ps_mul(op, factor)._2scalar)
+                 self._ps_mul(op, factor).as_iscalar)
         else:
             f = _0_0
         return f
@@ -1594,7 +1621,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             _mul_Fsum = Fsum._mul_Fsum
             if x > 4:
                 p = self
-                f = self if (x & 1) else _Psum_1()
+                f = self if (x & 1) else _Psum_(_1_0)
                 m = x >> 1  # // 2
                 while m:
                     p = _mul_Fsum(p, p, op)  # p **= 2
@@ -1605,7 +1632,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
                 f = _mul_Fsum(self, self, op)
                 if x > 2:  # self**3 or 4
                     p =  self if x < 4 else f
-                    f = _mul_Fsum(f, p, op)._2scalar
+                    f = _mul_Fsum(f, p, op).as_iscalar
             else:  # self**1 or self**0 == 1 or _1_0
                 f = self._pow_0_1(x, other)
         elif ps:  # self._ps[0]**x
@@ -1630,19 +1657,23 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
                     # assert x < 0  # < -1
                     s, r = f._fprs2 if isinstance(f, Fsum) else (f, 0)
                     if r:
-                        return _Psum_1()._ftruediv(f, op, **raiser)
+                        return _1_over(f, op, **raiser)  # PYCHOK 2 args
                     # use **= -1 for the CPython float_pow
                     # error if s is zero, and not s = 1 / s
                     x = -1
             elif x < 0:  # == -1: self**(-1) == 1 / self
                 if r:
-                    return _Psum_1()._ftruediv(self, op, **raiser)
+                    return _1_over(self, op, **raiser)  # PYCHOK 2 args
             else:  # self**1 or self**0
                 return self._pow_0_1(x, other)  # self, 1 or 1.0
-        elif r and self._raiser(r, s, **raiser):  # non-zero residual**fractional
-            # raise self._ResidualError(op, other, r, fractional_power=x)
-            t = _stresidual(_non_zero_, r, fractional_power=x)
-            raise self._Error(op, other, ResidualError, txt=t)
+        elif r:  # non-zero residual**fractional
+            if s:
+                n, d = self.as_integer_ratio()
+                if abs(n) > abs(d):
+                    n, d, x = d, n, (-x)
+                s = n / d
+            else:
+                s = r
         # assert isscalar(s) and isscalar(x)
         return self._pow_2_3(s, x, other, op, **raiser)
 
@@ -1701,11 +1732,22 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             yield -p
         yield _N_1_0
 
-    def _raiser(self, r, s, raiser=True):
+    def _raiser(self, r, s, raiser=True, **RESIDUAL):
         '''(INTERNAL) Does ratio C{r / s} exceed the RESIDUAL threshold?
         '''
-        self._ratio = t = fabs(r / s) if s else 0  # _0_0
-        return raiser and (t > self._RESIDUAL)
+        self._ratio = r = (r / s) if s else s  # == 0.
+        if r and raiser:
+            R = self._RESIDUAL
+            if RESIDUAL:
+                R = _xkwds_get(RESIDUAL, RESIDUAL=R)
+            return fabs(r) > R
+        return False
+
+    def _raiser2sum(self, r, s, **raiser_RESIDUAL):
+        '''(INTERNAL) Does ratio C{r / s} exceed the RESIDUAL threshold
+           I{and} is the residual B{C{r}} significant vs sum B{C{s}}?
+        '''
+        return self._raiser(r, s, **raiser_RESIDUAL) and _2sum(s, r) != (s, r)
 
     @property_RO
     def real(self):
@@ -1739,7 +1781,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
                            C{PYGEODESY_FSUM_RESIDUAL} or if omitted, keep the
                            current setting.
 
-           @return: The previous C{RESIDUAL} setting (C{float}), default C{0.}.
+           @return: The previous C{RESIDUAL} setting (C{float}), default C{0.0}.
 
            @raise ValueError: Negative B{C{threshold}}.
 
@@ -1777,18 +1819,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
 
            @see: Method L{Fsum.pow}.
         '''
-        _root_ = self.root.__name__
-        if isinstance(root, Fsum):
-            x = root.__rtruediv__(_1_0, **raiser)
-        else:
-            try:
-                x = _1_0 / _2float(root=root)
-            except Exception as X:
-                E, t = _xError2(X)
-                n = _SPACE_(_1_0, _truediv_op_, _root_)
-                raise E(n, root, txt=t, cause=X)
-        f = self._copy_2(self.root)
-        return f._fpow(x, _root_, **raiser)  # == pow(f, x)
+        x = _1_over(root, **raiser)
+        f =  self._copy_2(self.root)
+        return f._fpow(x, f.name, **raiser)  # == pow(f, x)
 
     def _scalar(self, other, op, **txt):
         '''(INTERNAL) Return scalar C{other}.
@@ -1797,13 +1830,6 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             return other
         raise self._TypeError(op, other, **txt)  # _invalid_
 
-    @property_RO
-    def _2scalar(self):
-        '''(INTERNAL) Get this instance as C{scalar} or C{as-is}.
-        '''
-        s, r = self._fprs2
-        return self if r else s
-
     def signOf(self, res=True):
         '''Determine the sign of this instance.
 
@@ -2049,23 +2075,14 @@ if __name__ == '__main__':
 
     def _test(n):
         # copied from Hettinger, see L{Fsum} reference
-        from pygeodesy import printf
-        from random import gauss, random, shuffle
+        from pygeodesy import frandoms, printf
 
         printf(_fsum.__name__, end=_COMMASPACE_)
         printf(_psum.__name__, end=_COMMASPACE_)
 
         F = Fsum()
         if F.is_math_fsum():
-            c = (7, 1e100, -7, -1e100, -9e-20, 8e-20) * 10
-            for _ in range(n):
-                t = list(c)
-                s = 0
-                for _ in range(n * 8):
-                    v = gauss(0, random())**7 - s
-                    t.append(v)
-                    s += v
-                shuffle(t)
+            for t in frandoms(n, seeded=True):
                 assert float(F.fset_(*t)) == _fsum(t)
                 printf(_DOT_, end=NN)
         printf(NN)

pygeodesy/lazily.py

@@ -260,7 +260,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'bqrt', 'cbrt', 'cbrt2', 'euclid', 'euclid_',
                                    'facos1', 'fasin1', 'fatan', 'fatan1', 'fatan2', 'favg',
                                    'fdot', 'fdot3', 'fmean', 'fmean_', 'fhorner', 'fidw', 'fpolynomial',
-                                   'fpowers', 'fprod', 'frange', 'freduce', 'fremainder',
+                                   'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder',
                                    'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',
                                    'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'),
                           formy=_i('Radical2Tuple',
@@ -504,7 +504,7 @@ class _ALL_MODS(object):
 _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.04.17'
+__version__ = '24.04.22'
 
 
 def _ALL_OTHER(*objs):