pygeodesy 24.5.6__py2.py3-none-any.whl → 24.5.8__py2.py3-none-any.whl

{PyGeodesy-24.5.6.dist-info → PyGeodesy-24.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyGeodesy
-Version: 24.5.6
+Version: 24.5.8
 Summary: Pure Python geodesy tools
 Home-page: https://GitHub.com/mrJean1/PyGeodesy
 Author: Jean M. Brouwers
@@ -114,7 +114,7 @@ line: ``epydoc --html --no-private --no-source --name=PyGeodesy --url=... -v pyg
 Tests
 =====
 
-The tests ran with Python 3.12.2 (with geographiclib_ 2.0), 3.11.5 (with geographiclib_ 2.0, numpy_
+The tests ran with Python 3.12.3 (with geographiclib_ 2.0), 3.11.5 (with geographiclib_ 2.0, numpy_
 1.24.2 and scipy_ 1.10.1), Python 3.10.8 (with geographiclib_ 2.0, numpy_ 1.23.3, scipy_ 1.9.1,
 GeoConvert_ 2.2, GeodSolve_ 2.2 and RhumbSolve_ 2.2), Python 3.9.6 and Python 2.7.18 (with geographiclib_
 1.50, numpy_ 1.16.6, scipy_ 1.2.2, GeoConvert_ 2.2, GeodSolve_ 2.2 and RhumbSolve_ 2.2), all on macOS
@@ -137,7 +137,7 @@ Python 3.11.5, 3.10.10 and 2.7.18 (all with geographiclib_ 1.52) on `Windows 10`
 A single-File and single-Directory application with ``pygeodesy`` has been bundled using PyInstaller_
 3.4 and 64-bit Python 3.7.4 and 3.7.3 on macOS 10.13.6 High Sierra.
 
-Previously, the tests were run with Python 3.12.0-1, 3.11.2-4, 3.10.1-7, 3.9.1, 3.8.7, 3.7.1, 2.7.15, PyPy_
+Previously, the tests were run with Python 3.12.0-2, 3.11.2-4, 3.10.1-7, 3.9.1, 3.8.7, 3.7.1, 2.7.15, PyPy_
 7.3.12 (Python 3.10.12), 7.3.1 (Python 3.6.9) and PyPy_ 7.1.1 (Python 2.7.13) (and geographiclib_ 1.52,
 numpy_ 1.16.3, 1.16.4, 1.16.6, 1.19.0, 1.19.4, 1.19.5 or 1.22.4 and scipy_ 1.2.1, 1.4.1, 1.5.2 or 1.8.1)
 on `Ubuntu 16.04`_, with Python 3.10.0-1, 3.9.0-5, 3.8.0-6, 3.7.2-6, 3.7.0, 3.6.2-5, 3.5.3, 2.7.13-17,
@@ -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: May 06, 2024.*
+*Last updated: May 08, 2024.*
 
 License
 =======

{PyGeodesy-24.5.6.dist-info → PyGeodesy-24.5.8.dist-info}/RECORD

@@ -1,9 +1,9 @@
 pygeodesy/LICENSE,sha256=YfgAiyxOwY6P9Kkb1_5XN81nueTLrpb3Ffkv3EuPgFU,1144
-pygeodesy/__init__.py,sha256=5Q85uqE7EHB5oDhKSCKkujvjELK-sTT7tomCX4OfaKE,40733
+pygeodesy/__init__.py,sha256=aWftpUqOeH1Uul8uN_kDAXbFL0TqLXDhynBhCmgpxoQ,40733
 pygeodesy/__main__.py,sha256=qMFG3caY8ZXWu6uGiemzyT4OqTFZnsFtlxcGCAgkVJw,4637
 pygeodesy/albers.py,sha256=g2AVlpV8JO2AYFCthoIbRC2h1OJqjb9P3hpwF0C3TI8,30994
 pygeodesy/azimuthal.py,sha256=tc4JxgLi-0jzU08m4Bvi-t-kzHXYPeGuzL3j_tyVFUA,50125
-pygeodesy/basics.py,sha256=Mh70LwAH185gr8aYhdOhfqAa-SkHvAatlJEOFIH7N8Y,28162
+pygeodesy/basics.py,sha256=GWsiv-Zl2qOZoW7wPwIG7yLd2FwYLUvsq8c6hZdgsFE,28453
 pygeodesy/booleans.py,sha256=HZbwoL-S7Ww9d4C2D1BVqXfmcuqqVpEVSU9_S0uyUyo,74204
 pygeodesy/cartesianBase.py,sha256=I3q29mRdBB3NCDmPoJsJ0QOFfLzkdMWc8X9zG4IwJyA,47264
 pygeodesy/clipy.py,sha256=VU3ynQ1IZ0v5hJlicqD48oW0imRgiL5_ZzRPrIjpfPw,27683
@@ -25,11 +25,11 @@ pygeodesy/elliptic.py,sha256=XRVpmpdm3hbztM4P-qhWKQizbgsXDUxWujgmOrIpgiQ,42428
 pygeodesy/epsg.py,sha256=ldHoLWqJWR4FUiBVnDTtrI_e7TNjjtr9OkxDlri1g5E,8165
 pygeodesy/errors.py,sha256=RHZ_f1zcOIyLQYProiQznaAOhojbDPDR4XbblXJMuS0,27232
 pygeodesy/etm.py,sha256=joEhU2lw9ehRv101nRpZvXq8hOYAEzdcYFpif9_obfk,44585
-pygeodesy/fmath.py,sha256=HCnndaXPwRIW8gGIVzbACftxIZZUUrRAiIAFfgVYLgw,33477
+pygeodesy/fmath.py,sha256=MylYc4nkVtDWI6U-R4hGmXcq-9tUUBmnlM795weezec,33477
 pygeodesy/formy.py,sha256=Rces4Q5ecED0WVfuI9mQzeyHE54LDowYfI6faBHpyeA,74536
 pygeodesy/frechet.py,sha256=qgee-ISBtT7Ov3rJkcd_t-WeXTbeNoMSQuMa0j3MyQc,33512
-pygeodesy/fstats.py,sha256=UcaUuUpnQqaE8T7rqHCT6eptqa-IG23LsiCiOUh43U0,25681
-pygeodesy/fsums.py,sha256=VttiMEC02riVsWWh2SqhLD3rwo2af0RsAvxvpiNSqsw,77895
+pygeodesy/fstats.py,sha256=23XqQRoegfeE4xEbbcgcsuw4JGEAe0OPvR8Jn2W8U-8,28414
+pygeodesy/fsums.py,sha256=M9btYPykj5JHvO4gg6wkKPGKlg9R4ZfdoFFKcgmQVno,78284
 pygeodesy/gars.py,sha256=fCiWBJ4kOJxPfNOxadX-OzBGDXj7C9g02NuGHiZa_88,11342
 pygeodesy/geodesicw.py,sha256=5yjJ2rLekSsjT7e-Km6v592ZcFlA41flQP_E42jU9Sw,26901
 pygeodesy/geodsolve.py,sha256=3GLI2_4gglzTpZwKchNzAv-XhWFBzWRKjcWsjCC3dvI,21900
@@ -37,7 +37,7 @@ pygeodesy/geohash.py,sha256=HwukecfkWvyfz9LHKfoA-WddQHYot_mB04o0lyWrKyU,32382
 pygeodesy/geoids.py,sha256=EwZJ50qRXeZb1591N99hnamM_EC2NP6MIhLb5swVHf4,80605
 pygeodesy/hausdorff.py,sha256=LJULGbDop4xqiWeRH5-Uayvk5WVCZQpxK4PCYu4kqSs,34192
 pygeodesy/heights.py,sha256=tjr-5eb8UXn2MAp6-157sb6qxPREFk5dtDjHtBgIgZ8,42528
-pygeodesy/interns.py,sha256=LzgIw5JEMLMc_56v0n3LxgpcQ0cpdRghkus8yorcuGQ,30188
+pygeodesy/interns.py,sha256=WuQe08kItPIwSJ9J1bUxI5yVOX_eNfpGIMpKHzoCqAw,30245
 pygeodesy/iters.py,sha256=CfU365eE9F4oWZbBx0qTEvfodMhpa8rGOepLIv67xF8,20181
 pygeodesy/karney.py,sha256=lYdsSHis8xQJVS1V0F3cphx6Dhgd77xTlMOdVR8MN8I,34994
 pygeodesy/ktm.py,sha256=sCvbLvJItavlruilAyjeZ0sOZx2yJumzGe_UiIVbGi4,27315
@@ -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.5.6.dist-info/METADATA,sha256=5ijdMD-qHxonaJpVNVWA0GMecR-fjfEAVCcSvFwWfuc,19363
-PyGeodesy-24.5.6.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
-PyGeodesy-24.5.6.dist-info/top_level.txt,sha256=cEQPatCXzKZqrivpULC5V5fuy9_V_bAwaP_gUGid7pQ,10
-PyGeodesy-24.5.6.dist-info/RECORD,,
+PyGeodesy-24.5.8.dist-info/METADATA,sha256=iiCbD7PToGDSIyOreeEG4YnJO2j2TZRnNvKeQdOVLQQ,19363
+PyGeodesy-24.5.8.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
+PyGeodesy-24.5.8.dist-info/top_level.txt,sha256=cEQPatCXzKZqrivpULC5V5fuy9_V_bAwaP_gUGid7pQ,10
+PyGeodesy-24.5.8.dist-info/RECORD,,

pygeodesy/__init__.py

@@ -121,7 +121,7 @@ C{epydoc --html --no-private --no-source --name=PyGeodesy --url=... -v pygeodesy
 Tests
 =====
 
-The tests ran with Python 3.12.2 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0,
+The tests ran with Python 3.12.3 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0,
 Python 3.11.5 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0, U{numpy
 <https://PyPI.org/project/numpy>} 1.24.2 and U{scipy<https://PyPI.org/project/scipy>} 1.10.1), Python
 3.10.8 (with U{geographiclib <https://PyPI.org/project/geographiclib>} 2.0, U{numpy
@@ -155,7 +155,7 @@ U{Debian 11<https://Cirrus-CI.com/github/mrJean1/PyGeodesy/master>} in 64-bit on
 A single-File and single-Directory application with C{pygeodesy} has been bundled using U{PyInstaller
 <https://PyPI.org/project/pyinstaller>} 3.4 and 64-bit Python 3.7.3 on macOS 10.13.6 High Sierra.
 
-Previously, the tests were run with Python 3.12.0-1, 3.11.2-4, 3.10.1-7, 3.9.1, 3.8.7, 3.7.1, 2.7.15, U{PyPy
+Previously, the tests were run with Python 3.12.0-2, 3.11.2-4, 3.10.1-7, 3.9.1, 3.8.7, 3.7.1, 2.7.15, U{PyPy
 <https://PyPy.org>} 7.3.12 (Python 3.10.12), 7.3.1 (Python 3.6.9) and U{PyPy<https://PyPy.org>} 7.1.1 (Python
 2.7.13) (and U{geographiclib <https://PyPI.org/project/geographiclib>} 1.52, U{numpy<https://PyPI.org/project/numpy>}
 1.16.3, 1.16.4, 1.16.6, 1.19.0, 1.19.4, 1.19.5 or 1.22.4 and U{scipy<https://PyPI.org/project/scipy>} 1.2.1, 1.4.1,
@@ -585,7 +585,7 @@ else:
     _init__all__ = False
 
 from pygeodesy.interns import _DOT_, _version2  # PYCHOK import
-__version__ = '24.05.06'
+__version__ = '24.05.08'
 # see setup.py for similar logic
 version     = _DOT_(*_version2(__version__, n=3))
 

pygeodesy/basics.py

@@ -21,7 +21,8 @@ from pygeodesy.errors import _AttributeError, _ImportError, _NotImplementedError
                              _xkwds_get
 from pygeodesy.interns import MISSING, NN, _1_, _by_, _COMMA_, _DOT_, _DEPRECATED_, \
                              _ELLIPSIS4_, _enquote, _EQUAL_, _in_, _invalid_, _N_A_, \
-                             _not_scalar_, _SPACE_, _UNDER_, _version_, _version_info
+                             _not_, _not_scalar_, _odd_, _SPACE_, _UNDER_, _version_, \
+                             _version_info
 # from pygeodesy.latlonBase import LatLonBase  # _MODS
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS, \
                              _getenv, LazyImportError, _sys, _sys_version_info2
@@ -34,13 +35,12 @@ from math import copysign as _copysign
 import inspect as _inspect
 
 __all__ = _ALL_LAZY.basics
-__version__ = '24.04.28'
+__version__ = '24.05.08'
 
 _0_0                  =  0.0  # in .constants
 _below_               = 'below'
 _list_tuple_types     = (list, tuple)
 _list_tuple_set_types = (list, tuple, set)
-_odd_                 = 'odd'
 _PYGEODESY_XPACKAGES_ = 'PYGEODESY_XPACKAGES'
 _required_            = 'required'
 
@@ -786,6 +786,15 @@ def _xisscalar(**names_values):
             raise _TypeError(n, v, txt=_not_scalar_)
 
 
+def _xiterable(obj):
+    '''(INTERNAL) Raise C{TypeError} if C{obj} is not iterable.
+    '''
+    # https://PyPI.org/project/isiterable/
+    if not (hasattr(obj, '__iter__') or
+            hasattr(obj, '__getitem__')):
+        raise TypeError(_not_(_xiterable.__name__[2:]))
+
+
 def _xnumpy(where, *required):
     '''(INTERNAL) Import C{numpy} and check required version.
     '''

pygeodesy/fmath.py

@@ -24,7 +24,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '24.05.06'
+__version__ = '24.05.07'
 
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ... sqrt(2) - 1
@@ -539,7 +539,7 @@ def fidw(xs, ds, beta=2):
                 i += 1  # len(xs) < i < len(ds)
             except Exception as X:
                 _I = Fmt.INDEX
-                raise _xError(X, _I(ds=i), d, _I(xs=i), x)
+                raise _xError(X, _I(xs=i), x, _I(ds=i), d)
         else:  # b == 0
             x = fsum(xs) / n  # fmean(xs)
             i = n

pygeodesy/fstats.py

@@ -7,43 +7,37 @@ L{pygeodesy.Fsum}, 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 isodd, islistuple, _xinstanceof, \
-                            _xsubclassof, _zip
-from pygeodesy.constants import _0_0, _2_0, _3_0, _4_0, _6_0
-from pygeodesy.errors import _AssertionError, _xError
-from pygeodesy.fmath import hypot2,  sqrt
-from pygeodesy.fsums import _Float, _2float, Fsum, _iadd_op_, \
-                            _isAn, _Fsum_Fsum2Tuple_types,  Fmt
-from pygeodesy.interns import NN, _invalid_, _other_, _SPACE_
+from pygeodesy.basics import isscalar, isodd, _xinstanceof, \
+                            _xiterable, _xsubclassof, _zip
+from pygeodesy.constants import _0_0, _1_0, _2_0, _3_0, _4_0, _6_0
+from pygeodesy.errors import _AssertionError, _ValueError, _xError
+from pygeodesy.fmath import Fsqrt
+from pygeodesy.fsums import _2finite, _Float, Fsum, _iadd_op_, \
+                            _isAn, _isFsumTuple, _Tuple,  Fmt
+from pygeodesy.interns import NN, _odd_, _SPACE_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 from pygeodesy.named import _Named, _NotImplemented, property_RO
 # from pygeodesy.props import property_RO  # from .named
 # from pygeodesy.streprs import Fmt  # from .fsums
 
-# from math import sqrt  # from .fmath
-
 __all__ = _ALL_LAZY.fstats
-__version__ = '24.05.06'
-
-_Floats = _Fsum_Fsum2Tuple_types + (_Float,)
-_Scalar = _Floats + (int,)  # XXX basics._Ints is ABCMeta in Python 2
-try:
-    _Scalar += (long,)
-except NameError:  # Python 3+
-    pass
+__version__ = '24.05.08'
 
 
 def _2Floats(**xs):
     '''(INTERNAL) Yield each value as C{float} or L{Fsum}.
     '''
     try:
-        _s, xs = xs.popitem()
-    except Exception as x:
-        raise _AssertionError(xs=xs, cause=x)
+        name, xs = xs.popitem()
+    except Exception as X:
+        raise _AssertionError(xs=xs, cause=X)
 
-    for i, x in enumerate(xs):  # don't unravel Fsums
-        yield x if _isAn(x, _Floats) else \
-             _2float(index=i, **{_s: x})
+    try:
+        i, x = 0, None
+        for i, x in enumerate(xs):  # don't unravel Fsums
+            yield x._Fsum if _isFsumTuple(x) else _2finite(x)
+    except Exception as X:
+        raise _xError(X, Fmt.INDEX(name, i), x)
 
 
 def _sampled(n, sample):
@@ -58,9 +52,11 @@ class _FstatsNamed(_Named):
     _n = 0
 
     def __add__(self, other):
-        '''Sum of this and a scalar, an L{Fsum} or an other instance.
+        '''Sum of this and an other instance or a C{scalar} or an
+           L{Fsum}, L{Fsum2Tuple} or
+           .
         '''
-        f  = self.fcopy(name=self.__add__.__name__)  # PYCHOK expected
+        f  = self.copy(name=self.__add__.__name__)  # PYCHOK expected
         f += other
         return f
 
@@ -73,7 +69,7 @@ class _FstatsNamed(_Named):
         return _NotImplemented(self)
 
     def __len__(self):
-        '''Return the I{total} number of accumulated values (C{int}).
+        '''Return the I{total} number of accumulated C{Scalars} (C{int}).
         '''
         return self._n
 
@@ -90,14 +86,14 @@ class _FstatsNamed(_Named):
         n = _SPACE_(self.classname, n) if n else self.classname
         return Fmt.SQUARE(n, len(self))
 
-    def fcopy(self, deep=False, name=NN):
+    def copy(self, deep=False, name=NN):
         '''Copy this instance, C{shallow} or B{C{deep}}.
         '''
-        n =  name or self.fcopy.__name__
+        n =  name or self.copy.__name__
         f = _Named.copy(self, deep=deep, name=n)
         return self._copy(f, self)  # PYCHOK expected
 
-    copy = fcopy
+    fcopy = copy  # for backward compatibility
 
 
 class _FstatsBase(_FstatsNamed):
@@ -105,13 +101,13 @@ class _FstatsBase(_FstatsNamed):
     '''
     _Ms = ()
 
-    def _copy(self, c, s):
+    def _copy(self, d, s):
         '''(INTERNAL) Copy C{B{c} = B{s}}.
         '''
-        _xinstanceof(self.__class__, c=c, s=s)
-        c._Ms = tuple(M.fcopy() for M in s._Ms)  # deep=False
-        c._n  =                          s._n
-        return c
+        _xinstanceof(self.__class__, d=d, s=s)
+        d._Ms = _Tuple(M.copy() for M in s._Ms)  # deep=False
+        d._n  =                          s._n
+        return d
 
     def fadd(self, xs, sample=False):  # PYCHOK no cover
         '''I{Must be overloaded}.'''
@@ -120,84 +116,85 @@ class _FstatsBase(_FstatsNamed):
     def fadd_(self, *xs, **sample):
         '''Accumulate and return the current count.
 
-           @see: Method C{fadd}.
+           @see: Method C{fadd} for further details.
         '''
         return self.fadd(xs, **sample)
 
     def fmean(self, xs=None):
         '''Accumulate and return the current mean.
 
-           @kwarg xs: Iterable with additional values (C{Scalar}s).
+           @kwarg xs: Iterable of additional values (each C{scalar} or
+                      an L{Fsum} or L{Fsum2Tuple} instance).
 
            @return: Current, running mean (C{float}).
 
            @see: Method C{fadd}.
         '''
-        if xs:
-            self.fadd(xs)
-        return self._M1.fsum()
+        return _Float(self._Mean(xs))
 
     def fmean_(self, *xs):
         '''Accumulate and return the current mean.
 
-           @see: Method C{fmean}.
+           @see: Method C{fmean} for further details.
         '''
         return self.fmean(xs)
 
-    def fstdev(self, xs=None, sample=False):
+    def fstdev(self, xs=None, **sample):
         '''Accumulate and return the current standard deviation.
 
-           @kwarg xs: Iterable with additional values (C{Scalar}).
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} standard deviation (C{bool}).
+           @arg xs: Iterable of additional values (each C{scalar} or an
+                    L{Fsum} or L{Fsum2Tuple} instance).
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} deviation
+                          instead of the I{population} deviation (C{bool}).
 
            @return: Current, running (sample) standard deviation (C{float}).
 
            @see: Method C{fadd}.
         '''
-        v = self.fvariance(xs, sample=sample)
-        return sqrt(v) if v > 0 else _0_0
+        return _Float(self._Stdev(xs, **sample))
 
     def fstdev_(self, *xs, **sample):
         '''Accumulate and return the current standard deviation.
 
-           @see: Method C{fstdev}.
+           @see: Method C{fstdev} for further details.
         '''
         return self.fstdev(xs, **sample)
 
-    def fvariance(self, xs=None, sample=False):
+    def fvariance(self, xs=None, **sample):
         '''Accumulate and return the current variance.
 
-           @kwarg xs: Iterable with additional values (C{Scalar}s).
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} variance (C{bool}).
+           @arg xs: Iterable of additional values (each C{scalar} or an
+                    L{Fsum} or L{Fsum2Tuple} instance).
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} variance
+                          instead of the I{population} variance (C{bool}).
 
            @return: Current, running (sample) variance (C{float}).
 
            @see: Method C{fadd}.
         '''
-        n = self.fadd(xs, sample=sample)
-        return _Float(self._M2 / _Float(n)) if n > 0 else _0_0
+        return _Float(self._Variance(xs, **sample))
 
     def fvariance_(self, *xs, **sample):
         '''Accumulate and return the current variance.
 
-           @see: Method C{fvariance}.
+           @see: Method C{fvariance} for further details.
         '''
         return self.fvariance(xs, **sample)
 
     def _iadd_other(self, other):
-        '''(INTERNAL) Add Scalar or Scalars.
-        '''
-        if _isAn(other, _Scalar):
-            self.fadd_(other)
-        else:
-            try:
-                if not islistuple(other):
-                    raise TypeError(_SPACE_(_invalid_, _other_))
+        '''(INTERNAL) Add one or several values.
+        '''
+        try:
+            if _isFsumTuple(other):
+                self.fadd_(other._Fsum)
+            elif isscalar(other):
+                self.fadd_(_2finite(other))
+            else:  # iterable?
+                _xiterable(other)
                 self.fadd(other)
-            except Exception as x:
-                raise _xError(x, _SPACE_(self, _iadd_op_, repr(other)))
+        except Exception as x:
+            t = _SPACE_(self, _iadd_op_, repr(other))
+            raise _xError(x, t)
 
     @property_RO
     def _M1(self):
@@ -209,6 +206,25 @@ class _FstatsBase(_FstatsNamed):
         '''(INTERNAL) get the 2nd Moment accumulator.'''
         return self._Ms[1]
 
+    def _Mean(self, xs=None):
+        '''(INTERNAL) Return the current mean as L{Fsum}.
+        '''
+        if xs:
+            self.fadd(xs)
+        return self._M1  # .copy()
+
+    def _Stdev(self, xs=None, **sample):
+        '''(INTERNAL) Return the current (sample) standard deviation as L{Fsum}.
+        '''
+        V = self._Variance(xs, **sample)
+        return Fsqrt(V) if V > 0 else _0_0
+
+    def _Variance(self, xs=None, **sample):
+        '''(INTERNAL) Return the current (sample) variance as L{Fsum}.
+        '''
+        n = self.fadd(xs, **sample)
+        return (self._M2 / n) if n > 0 else _0_0
+
 
 class Fcook(_FstatsBase):
     '''U{Cook<https://www.JohnDCook.com/blog/skewness_kurtosis>}'s
@@ -222,12 +238,13 @@ class Fcook(_FstatsBase):
     def __init__(self, xs=None, name=NN):
         '''New L{Fcook} stats accumulator.
 
-           @kwarg xs: Iterable with initial values (C{Scalar}s).
+           @arg xs: Iterable of additional values (each C{scalar} or
+                    an L{Fsum} or L{Fsum2Tuple} instance).
            @kwarg name: Optional name (C{str}).
 
            @see: Method L{Fcook.fadd}.
         '''
-        self._Ms = tuple(Fsum() for _ in range(4))  # 1st, 2nd ... Moment
+        self._Ms = _Tuple(Fsum() for _ in range(4))  # 1st, 2nd ... Moment
         if name:
             self.name = name
         if xs:
@@ -236,14 +253,15 @@ class Fcook(_FstatsBase):
     def __iadd__(self, other):
         '''Add B{C{other}} to this L{Fcook} instance.
 
-           @arg other: An L{Fcook} instance or C{Scalar}s, meaning
-                       one or more C{scalar} or L{Fsum} instances.
+           @arg other: An L{Fcook} instance or value or iterable
+                       of values (each C{scalar} or an L{Fsum}
+                       or L{Fsum2Tuple} instance).
 
            @return: This instance, updated (L{Fcook}).
 
-           @raise TypeError: Invalid B{C{other}} type.
+           @raise TypeError: Invalid B{C{other}}.
 
-           @raise ValueError: Invalid B{C{other}}.
+           @raise ValueError: Invalid or non-finite B{C{other}}.
 
            @see: Method L{Fcook.fadd}.
         '''
@@ -256,9 +274,9 @@ class Fcook(_FstatsBase):
                     B1, B2, B3, B4 = other._Ms
 
                     n   =  na + nb
-                    n_  = _Float(n)
+                    _n  = _1_0 / n
                     D   =  A1 - B1  # b1 - a1
-                    Dn  =  D / n_
+                    Dn  =  D * _n
                     Dn2 =  Dn**2  # d**2 / n**2
                     nab =  na * nb
                     Dn3 =  Dn2 * (D * nab)
@@ -271,16 +289,16 @@ class Fcook(_FstatsBase):
                     A4 += (Dn * Dn3) * (na2 - nab + nb2)  # d**4 / n**3
 
                     A3 +=  B3
-                    A3 += (A2 *  na - (B2 * nb)) * (Dn * _3_0)
+                    A3 += (A2 * na - (B2 * nb)) * (Dn * _3_0)
                     A3 +=  Dn3 * (na - nb)
 
                     A2 += B2
-                    A2 += Dn2 * (nab / n_)
+                    A2 += Dn2 * (nab * _n)
 
                     B1n = B1 * nb  # if other is self
                     A1 *= na
                     A1 += B1n
-                    A1 *= 1 / n_  # /= chokes PyChecker
+                    A1 *= _n
 
 #                   self._Ms = A1, A2, A3, A4
                     self._n  = n
@@ -293,18 +311,18 @@ class Fcook(_FstatsBase):
     def fadd(self, xs, sample=False):
         '''Accumulate and return the current count.
 
-           @arg xs: Iterable with additional values (C{Scalar}s,
-                    meaning C{scalar} or L{Fsum} instances).
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} count (C{bool}).
+           @arg xs: Iterable of additional values (each C{scalar} or an
+                    L{Fsum} or L{Fsum2Tuple} instance).
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} count
+                          instead of the I{population} count (C{bool}).
 
            @return: Current, running (sample) count (C{int}).
 
            @raise OverflowError: Partial C{2sum} overflow.
 
-           @raise TypeError: Non-scalar B{C{xs}} value.
+           @raise TypeError: Invalid B{C{xs}}.
 
-           @raise ValueError: Invalid or non-finite B{C{xs}} value.
+           @raise ValueError: Invalid or non-finite B{C{xs}}.
 
            @see: U{online_kurtosis<https://WikiPedia.org/wiki/
                  Algorithms_for_calculating_variance>}.
@@ -312,7 +330,7 @@ class Fcook(_FstatsBase):
         n = self._n
         if xs:
             M1, M2, M3, M4 = self._Ms
-            for x in _2Floats(xs=xs):
+            for x in _2Floats(xs=xs):  # PYCHOK yield
                 n1 = n
                 n += 1
                 D  = x - M1
@@ -342,38 +360,38 @@ class Fcook(_FstatsBase):
             self._n  = n
         return _sampled(n, sample)
 
-    def fjb(self, xs=None, sample=True, excess=True):
+    def fjb(self, xs=None, excess=True, sample=True):
         '''Accumulate and compute the current U{Jarque-Bera
            <https://WikiPedia.org/wiki/Jarque–Bera_test>} normality.
 
-           @kwarg xs: Iterable with additional values (C{Scalar}s).
-           @kwarg sample: Return the I{sample} normality (C{bool}), default.
-           @kwarg excess: Return the I{excess} kurtosis (C{bool}), default.
+           @kwarg xs: Iterable of additional values (each C{scalar} or an
+                      L{Fsum} or L{Fsum2Tuple}).
+           @kwarg excess: Apply the I{excess} kurtosis (C{bool}), default.
+           @kwarg sample: Use C{B{sample}=False} for the I{population}
+                          normality instead of the I{sample} one (C{bool}).
 
            @return: Current, running (sample) Jarque-Bera normality (C{float}).
 
            @see: Method L{Fcook.fadd}.
         '''
-        n = self.fadd(xs,  sample=sample)
-        k = self.fkurtosis(sample=sample, excess=excess) / _2_0
-        s = self.fskewness(sample=sample)
-        return n * hypot2(k, s) / _6_0
+        return _Float(self._JarqueBera(xs, excess, sample=sample))
 
     def fjb_(self, *xs, **sample_excess):
         '''Accumulate and compute the current U{Jarque-Bera
            <https://WikiPedia.org/wiki/Jarque–Bera_test>} normality.
 
-           @see: Method L{Fcook.fjb}.
+           @see: Method L{Fcook.fjb} for further details.
         '''
         return self.fjb(xs, **sample_excess)
 
-    def fkurtosis(self, xs=None, sample=False, excess=True):
+    def fkurtosis(self, xs=None, excess=True, **sample):
         '''Accumulate and return the current kurtosis.
 
-           @kwarg xs: Iterable with additional values (C{Scalar}s).
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} kurtosis (C{bool}).
+           @arg xs: Iterable of additional values (each C{scalar} or an
+                    L{Fsum} or L{Fsum2Tuple} instance).
            @kwarg excess: Return the I{excess} kurtosis (C{bool}), default.
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} kurtosis
+                          instead of the I{population} kurtosis (C{bool}).
 
            @return: Current, running (sample) kurtosis or I{excess} kurtosis (C{float}).
 
@@ -382,32 +400,21 @@ class Fcook(_FstatsBase):
 
            @see: Method L{Fcook.fadd}.
         '''
-        k, n = _0_0, self.fadd(xs, sample=sample)
-        if n > 0:
-            _, M2, _, M4 = self._Ms
-            m2 = _Float(M2 * M2)
-            if m2:
-                K, x = (M4 * (n / m2)), _3_0
-                if sample and 2 < n < len(self):
-                    d  = _Float((n - 1) * (n - 2))
-                    K *=        (n + 1) * (n + 2) / d
-                    x *= n**2 / d
-                if excess:
-                    K -= x
-                k = K.fsum()
-        return k
+        n = self.fadd(xs, **sample)
+        return _Float(self._Kurtosis(n, excess, **sample))
 
-    def fkurtosis_(self, *xs, **sample_excess):
+    def fkurtosis_(self, *xs, **excess_sample):
         '''Accumulate and return the current kurtosis.
 
-           @see: Method L{Fcook.fkurtosis}.
+           @see: Method L{Fcook.fkurtosis} for further details.
         '''
-        return self.fkurtosis(xs, **sample_excess)
+        return self.fkurtosis(xs, **excess_sample)
 
     def fmedian(self, xs=None):
         '''Accumulate and return the current median.
 
-           @kwarg xs: Iterable with additional values (C{Scalar}s).
+           @arg xs: Iterable of additional values (each C{scalar} or an
+                    L{Fsum} or L{Fsum2Tuple} instance).
 
            @return: Current, running median (C{float}).
 
@@ -416,24 +423,22 @@ class Fcook(_FstatsBase):
                  https://TowardsDataScience.com/skewness-kurtosis-simplified-1338e094fc85>}
                  and method L{Fcook.fadd}.
         '''
-        # skewness = 3 * (mean - median) / stdev, i.e.
-        # median = mean - skewness * stdef / 3
-        m = _Float(self._M1) if xs is None else self.fmean(xs)
-        return m - self.fskewness() * self.fstdev() / _3_0
+        return _Float(self._Median(xs))
 
     def fmedian_(self, *xs):
         '''Accumulate and return the current median.
 
-           @see: Method L{Fcook.fmedian}.
+           @see: Method L{Fcook.fmedian} for further details.
         '''
         return self.fmedian(xs)
 
-    def fskewness(self, xs=None, sample=False):
+    def fskewness(self, xs=None, **sample):
         '''Accumulate and return the current skewness.
 
-           @kwarg xs: Iterable with additional values (C{Scalar}s).
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} skewness (C{bool}).
+           @arg xs: Iterable of additional values (each C{scalar} or an
+                    L{Fsum} or L{Fsum2Tuple} instance).
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} skewness
+                          instead of the I{population} skewness (C{bool}).
 
            @return: Current, running (sample) skewness (C{float}).
 
@@ -442,29 +447,70 @@ class Fcook(_FstatsBase):
 
            @see: Method L{Fcook.fadd}.
         '''
-        s, n = _0_0, self.fadd(xs, sample=sample)
-        if n > 0:
-            _, M2, M3, _ = self._Ms
-            m = _Float(M2**3)
-            if m > 0:
-                S = M3 * sqrt(_Float(n) / m)
-                if sample and 1 < n < len(self):
-                    S *= (n + 1) / _Float(n - 1)
-                s = S.fsum()
-        return s
+        n = self.fadd(xs, **sample)
+        return _Float(self._Skewness(n, **sample))
 
     def fskewness_(self, *xs, **sample):
         '''Accumulate and return the current skewness.
 
-           @see: Method L{Fcook.fskewness}.
+           @see: Method L{Fcook.fskewness} for further details.
         '''
         return self.fskewness(xs, **sample)
 
+    def _JarqueBera(self, xs, excess, **sample):
+        '''(INTERNAL) Return the (sample) Jarque-Bera normality as L{Fsum}.
+        '''
+        N, n = _0_0, self.fadd(xs, **sample)
+        if n > 0:
+            K = self._Kurtosis(n, excess, **sample) / _2_0
+            S = self._Skewness(n,         **sample)
+            N = (K**2 + S**2) * (n / _6_0)  # Fpowers(2, K, S) * ...
+        return N
+
+    def _Kurtosis(self, n, excess, sample=False):
+        '''(INTERNAL) Return the (sample) kurtosis as L{Fsum} or C{0.0}.
+        '''
+        K = _0_0
+        if n > 0:
+            _, M2, _, M4 = self._Ms
+            M = M2**2
+            if M > 0:
+                K, x = M.rdiv(M4 * n, raiser=False), _3_0
+                if sample and 2 < n < len(self):
+                    d  = (n - 1) * (n - 2)
+                    K *= (n + 1) * (n + 2) / d
+                    x *=  n**2 / d
+                if excess:
+                    K -= x
+        return K
+
+    def _Median(self, xs=None):
+        '''(INTERNAL) Return the median as L{Fsum}.
+        '''
+        # skewness = 3 * (mean - median) / stdev, i.e.
+        # median = mean - (skewness * stdef) / 3
+        return self._Mean(xs) - (self._Skewness(self._n) *
+                                 self._Stdev()) / _3_0
+
+    def _Skewness(self, n, sample=False):
+        '''(INTERNAL) Return the (sample) skewness as L{Fsum} or C{0.0}.
+        '''
+        S = _0_0
+        if n > 0:
+            _, M2, M3, _ = self._Ms
+            M = M2**3
+            if M > 0:
+                M = M.rdiv(n, raiser=False)
+                S = M3 * Fsqrt(M, raiser=False)
+                if sample and 1 < n < len(self):
+                    S *= (n + 1) / (n - 1)
+        return S
+
     def toFwelford(self, name=NN):
         '''Return an L{Fwelford} equivalent.
         '''
         f = Fwelford(name=name or self.name)
-        f._Ms = self._M1.fcopy(), self._M2.fcopy()  # deep=False
+        f._Ms = self._M1.copy(), self._M2.copy()  # deep=False
         f._n  = self._n
         return f
 
@@ -478,7 +524,8 @@ class Fwelford(_FstatsBase):
     def __init__(self, xs=None, name=NN):
         '''New L{Fwelford} stats accumulator.
 
-           @kwarg xs: Iterable with initial values (C{Scalar}s).
+           @arg xs: Iterable of initial values (each C{scalar} or an
+                    L{Fsum} or L{Fsum2Tuple} instance).
            @kwarg name: Optional name (C{str}).
 
            @see: Method L{Fwelford.fadd}.
@@ -492,12 +539,13 @@ class Fwelford(_FstatsBase):
     def __iadd__(self, other):
         '''Add B{C{other}} to this L{Fwelford} instance.
 
-           @arg other: An L{Fwelford} or L{Fcook} instance or C{Scalar}s,
-                       meaning one or more C{scalar} or L{Fsum} instances.
+           @arg other: An L{Fwelford} or L{Fcook} instance or value
+                       or an iterable of values (each C{scalar} or
+                       an L{Fsum} or L{Fsum2Tuple} instance).
 
            @return: This instance, updated (L{Fwelford}).
 
-           @raise TypeError: Invalid B{C{other}} type.
+           @raise TypeError: Invalid B{C{other}}.
 
            @raise ValueError: Invalid B{C{other}}.
 
@@ -513,18 +561,18 @@ class Fwelford(_FstatsBase):
                     M_, S_ = other._Ms
 
                     n  =  na + nb
-                    n_ = _Float(n)
+                    _n = _1_0 / n
 
                     D  = M_ - M
                     D *= D  # D**2
-                    D *= na * nb / n_
+                    D *= na * nb * _n
                     S += D
                     S += S_
 
                     Mn = M_ * nb  # if other is self
                     M *= na
                     M += Mn
-                    M *= 1 / n_  # /= chokes PyChecker
+                    M *= _n
 
 #                   self._Ms = M, S
                     self._n  = n
@@ -540,23 +588,23 @@ class Fwelford(_FstatsBase):
     def fadd(self, xs, sample=False):
         '''Accumulate and return the current count.
 
-           @arg xs: Iterable with additional values (C{Scalar}s,
-                    meaning C{scalar} or L{Fsum} instances).
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} count (C{bool}).
+           @arg xs: Iterable of additional values (each C{scalar} or an
+                    L{Fsum} or L{Fsum2Tuple} instance).
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} count
+                          instead of the I{population} count (C{bool}).
 
            @return: Current, running (sample) count (C{int}).
 
            @raise OverflowError: Partial C{2sum} overflow.
 
-           @raise TypeError: Non-scalar B{C{xs}} value.
+           @raise TypeError: Invalid B{C{xs}}.
 
-           @raise ValueError: Invalid or non-finite B{C{xs}} value.
+           @raise ValueError: Invalid or non-finite B{C{xs}}.
         '''
         n = self._n
         if xs:
             M, S = self._Ms
-            for x in _2Floats(xs=xs):
+            for x in _2Floats(xs=xs):  # PYCHOK yield
                 n += 1
                 D  = x - M
                 M += D / n
@@ -575,14 +623,16 @@ class Flinear(_FstatsNamed):
     def __init__(self, xs=None, ys=None, Fstats=Fwelford, name=NN):
         '''New L{Flinear} regression accumulator.
 
-           @kwarg xs: Iterable with initial C{x} values (C{Scalar}s).
-           @kwarg ys: Iterable with initial C{y} values (C{Scalar}s).
-           @kwarg Fstats: Stats class for C{x} and C{y} values (L{Fcook}
-                          or L{Fwelford}).
+           @kwarg xs: Iterable of initial C{x} values (each C{scalar} or
+                      an L{Fsum} or L{Fsum2Tuple} instance).
+           @kwarg ys: Iterable of initial C{y} values (each C{scalar} or
+                      an L{Fsum} or L{Fsum2Tuple} instance).
+           @kwarg Fstats: Class for C{xs} and C{ys} values (L{Fcook} or
+                          L{Fwelford}).
            @kwarg name: Optional name (C{str}).
 
-           @raise TypeError: Invalid B{C{Fs}}, not L{Fcook} or
-                              L{Fwelford}.
+           @raise TypeError: B{C{Fstats}} not L{Fcook} or L{Fwelford}.
+
            @see: Method L{Flinear.fadd}.
         '''
         _xsubclassof(Fcook, Fwelford, Fstats=Fstats)
@@ -598,8 +648,8 @@ class Flinear(_FstatsNamed):
     def __iadd__(self, other):
         '''Add B{C{other}} to this instance.
 
-           @arg other: An L{Flinear} instance or C{Scalar} pairs,
-                       meaning C{scalar} or L{Fsum} instances.
+           @arg other: An L{Flinear} instance or an iterable of
+                       C{x_ys} values, see method C{fadd_}.
 
            @return: This instance, updated (L{Flinear}).
 
@@ -614,126 +664,139 @@ class Flinear(_FstatsNamed):
         if _isAn(other, Flinear):
             if len(other) > 0:
                 if len(self) > 0:
-                    n = other._n
-                    S = other._S
-                    X = other._X
-                    Y = other._Y
-                    D = (X._M1 - self._X._M1) * \
-                        (Y._M1 - self._Y._M1) * \
-                        (n     * self._n / _Float(n + self._n))
+                    n =  other._n
+                    D = (other._X._M1 - self._X._M1) * \
+                        (other._Y._M1 - self._Y._M1) * \
+                        (n * self._n / (self._n + n))
+                    self._S += other._S + D
+                    self._X += other._X
+                    self._Y += other._Y
                     self._n += n
-                    self._S += S + D
-                    self._X += X
-                    self._Y += Y
                 else:
                     self._copy(self, other)
         else:
             try:
-                if not islistuple(other):
-                    raise TypeError(_SPACE_(_invalid_, _other_))
-                elif isodd(len(other)):
-                    raise ValueError(Fmt.PAREN(isodd=Fmt.PAREN(len=_other_)))
+                _xiterable(other)
                 self.fadd_(*other)
             except Exception as x:
-                raise _xError(x, _SPACE_(self, _iadd_op_, repr(other)))
+                op = _SPACE_(self, _iadd_op_, repr(other))
+                raise _xError(x, op)
         return self
 
-    def _copy(self, c, s):
-        '''(INTERNAL) Copy C{B{c} = B{s}}.
+    def _copy(self, d, s):
+        '''(INTERNAL) Copy C{B{d} = B{s}}.
+        '''
+        _xinstanceof(Flinear, d=d, s=s)
+        d._S = s._S.copy(deep=False)
+        d._X = s._X.copy(deep=False)
+        d._Y = s._Y.copy(deep=False)
+        d._n = s._n
+        return d
+
+    def _Correlation(self, **sample):
+        '''(INTERNAL) Return the current (sample) correlation as L{Fsum}.
         '''
-        _xinstanceof(Flinear, c=c, s=s)
-        c._n = s._n
-        c._S = s._S.fcopy(deep=False)
-        c._X = s._X.fcopy(deep=False)
-        c._Y = s._Y.fcopy(deep=False)
-        return c
+        return self._Sampled(self._X._Stdev(**sample) *
+                             self._Y._Stdev(**sample), **sample)
 
     def fadd(self, xs, ys, sample=False):
         '''Accumulate and return the current count.
 
-           @arg xs: Iterable with additional C{x} values (C{Scalar}s),
-                    meaning C{scalar} or L{Fsum} instances).
-           @arg ys: Iterable with additional C{y} values (C{Scalar}s,
-                    meaning C{scalar} or L{Fsum} instances).
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} count (C{bool}).
+           @arg xs: Iterable of additional C{x} values (each C{scalar}
+                    or an L{Fsum} or L{Fsum2Tuple} instance).
+           @arg ys: Iterable of additional C{y} values (each C{scalar}
+                    or an L{Fsum} or L{Fsum2Tuple} instance).
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} count
+                          instead of the I{population} count (C{bool}).
 
            @return: Current, running (sample) count (C{int}).
 
            @raise OverflowError: Partial C{2sum} overflow.
 
-           @raise TypeError: Non-scalar B{C{xs}} or B{C{ys}} value.
+           @raise TypeError: Invalid B{C{xs}} or B{C{ys}}.
 
-           @raise ValueError: Invalid or non-finite B{C{xs}} or B{C{ys}} value.
+           @raise ValueError: Invalid or non-finite B{C{xs}} or B{C{ys}}.
         '''
         n = self._n
         if xs and ys:
             S = self._S
             X = self._X
             Y = self._Y
-            for x, y in _zip(_2Floats(xs=xs), _2Floats(ys=ys)):  # strict=True
+            for x, y in _zip(_2Floats(xs=xs), _2Floats(ys=ys)):  # PYCHOK strict=True
                 n1 = n
                 n += 1
                 if n1 > 0:
-                    S += (X._M1 - x) * (Y._M1 - y) * (n1 / _Float(n))
+                    S += (X._M1 - x) * (Y._M1 - y) * (n1 / n)
                 X += x
                 Y += y
-            self._n  = n
+            self._n = n
         return _sampled(n, sample)
 
     def fadd_(self, *x_ys, **sample):
         '''Accumulate and return the current count.
 
-           @arg x_ys: Individual, alternating C{x, y, x, y, ...}
-                      positional values (C{Scalar}s).
+           @arg x_ys: Individual, alternating C{x, y, x, y, ...} values
+                      (each C{scalar} or an L{Fsum} or L{Fsum2Tuple}
+                      instance).
 
-           @see: Method C{Flinear.fadd}.
+           @see: Method C{Flinear.fadd} for further details.
         '''
+        if isodd(len(x_ys)):
+            t = _SPACE_(_odd_, len.__name__)
+            raise _ValueError(t, len(x_ys))
         return self.fadd(x_ys[0::2], x_ys[1::2], **sample)
 
-    def fcorrelation(self, sample=False):
+    def fcorrelation(self, **sample):
         '''Return the current, running (sample) correlation (C{float}).
 
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} correlation (C{bool}).
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} correlation
+                          instead of the I{population} correlation (C{bool}).
         '''
-        return self._sampled(self.x.fstdev(sample=sample) *
-                             self.y.fstdev(sample=sample), sample)
+        return _Float(self._Correlation(**sample))
 
-    def fintercept(self, sample=False):
+    def fintercept(self, **sample):
         '''Return the current, running (sample) intercept (C{float}).
 
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} intercept (C{bool}).
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} intercept
+                          instead of the I{population} intercept (C{bool}).
         '''
-        return _Float(self.y._M1 -
-                     (self.x._M1 * self.fslope(sample=sample)))
+        return _Float(self._Intercept(**sample))
 
-    def fslope(self, sample=False):
+    def fslope(self, **sample):
         '''Return the current, running (sample) slope (C{float}).
 
-           @kwarg sample: Return the I{sample} instead of the entire
-                          I{population} slope (C{bool}).
+           @kwarg sample: Use C{B{sample}=True} for the I{sample} slope
+                          instead of the I{population} slope (C{bool}).
         '''
-        return self._sampled(self.x.fvariance(sample=sample), sample)
+        return _Float(self._Slope(**sample))
 
-    def _sampled(self, t, sample):
+    def _Intercept(self, **sample):
+        '''(INTERNAL) Return the current (sample) intercept as L{Fsum}.
+        '''
+        return self._Y._M1 - self._X._M1 * self._Slope(**sample)
+
+    def _Sampled(self, T, sample=False):
         '''(INTERNAL) Compute the sampled or entire population result.
         '''
-        t *= _Float(_sampled(self._n, sample))
-        return _Float(self._S / t) if t else _0_0
+        T *= _sampled(self._n, sample)
+        return self._S.copy().fdiv(T, raiser=False) if T else T
+
+    def _Slope(self, **sample):
+        '''(INTERNAL) Return the current (sample) slope as L{Fsum}.
+        '''
+        return self._Sampled(self._X._Variance(**sample), **sample)
 
     @property_RO
     def x(self):
         '''Get the C{x} accumulator (L{Fcook} or L{Fwelford}).
         '''
-        return self._X
+        return self._X  # .copy()
 
     @property_RO
     def y(self):
         '''Get the C{y} accumulator (L{Fcook} or L{Fwelford}).
         '''
-        return self._Y
+        return self._Y  # .copy()
 
 
 __all__ += _ALL_DOCS(_FstatsBase, _FstatsNamed)

pygeodesy/fsums.py

@@ -43,7 +43,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.05.06'
+__version__ = '24.05.08'
 
 _abs          =  abs
 _add_op_      = _PLUS_  # in .auxilats.auxAngle
@@ -71,7 +71,7 @@ _significant_ = 'significant'
 _sub_op_      = _DASH_  # in .auxilats.auxAngle
 _threshold_   = 'threshold'
 _truediv_op_  = _SLASH_
-_Tuple        =  tuple
+_Tuple        =  tuple  # in .fstats
 _divmod_op_   = _floordiv_op_ + _mod_op_
 _isub_op_     = _sub_op_ + _fset_op_  # in .auxilats.auxAngle
 
@@ -86,19 +86,25 @@ def _2delta(*ab):
     return _Float(a if fabs(a) > fabs(b) else b)
 
 
-def _2error(unused):
+def _2error(unused):  # in .fstats
     '''(INTERNAL) Throw a C{not-finite} exception.
     '''
     raise ValueError(_not_finite_)
 
 
+def _2finite(x):
+    '''(INTERNAL) return C{float(x)} if finite.
+    '''
+    x = _Float(x)
+    return x if _isfinite(x) else _2error(x)
+
+
 def _2float(index=None, **name_value):  # in .fmath, .fstats
     '''(INTERNAL) Raise C{TypeError} or C{ValueError} if not scalar or infinite.
     '''
     n, v = name_value.popitem()  # _xkwds_item2(name_value)
     try:
-        v = _Float(v)
-        return v if _isfinite(v) else _2error(v)
+        return _2finite(v)
     except Exception as X:
         raise _xError(X, Fmt.INDEX(n, index), v)
 
@@ -838,7 +844,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         c = _ceil(s) + int(r) - 1
         while r > (c - s):  # (s + r) > c
             c += 1
-        return c
+        return c  # _ceil(self._n_d)
 
     cmp = __cmp__
 
@@ -1149,7 +1155,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         f = _floor(s) + _floor(r) + 1
         while (f - s) > r:  # f > (s + r)
             f -= 1
-        return f
+        return f  # _floor(self._n_d)
 
 #   ffloordiv = __ifloordiv__  # for naming consistency
 #   floordiv  = __floordiv__   # for naming consistency
@@ -1222,7 +1228,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
            @note: The precision running C{fsum} after a C{//=} or
                   C{//} C{floor} division is C{int} in Python 3+.
         '''
-        return self._fprs2.fsum
+        s, _ = self._fprs2
+        return s  # ._fprs2.fsum
 
     @Property_RO
     def _fprs2(self):
@@ -1259,7 +1266,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
 
            @see: Method L{Fsum.fadd} for further details.
         '''
-        f = Fsum(*xs) if xs else _0_0
+        f = xs[0] if len(xs) == 1 else (
+            Fsum(*xs) if xs else _0_0)
         return self._fset(f)
 
     def _fset(self, other, as_is=True, n=0, up=True):
@@ -1356,7 +1364,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         return self._facc_1(xs)._fprs
 
     @property_RO
-    def _Fsum(self):  # like L{Fsum2Tuple._Fsum}, for C{_2floats}.
+    def _Fsum(self):  # like L{Fsum2Tuple._Fsum}, for C{_2floats}, .fstats
         return self  # NOT @Property_RO, see .copy and ._copy_2
 
     def Fsum_(self, *xs, **name):
@@ -1559,13 +1567,18 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         '''
         # assert isscalar(factor)
         if self._ps and self._finite(factor, op):
-            f =  self      if factor == _1_0 else (
+            f =  self      if factor == _1_0   else (
                  self._neg if factor == _N_1_0 else
                  self._ps_mul(op, factor).as_iscalar)
         else:
             f = _0_0
         return f
 
+#   @property_RO
+#   def _n_d(self):
+#       n, d = self.as_integer_ratio()
+#       return n / d
+
     @property_RO
     def _neg(self):
         '''(INTERNAL) Return C{Fsum(-self)} or scalar C{NEG0}.
@@ -1751,8 +1764,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         return ps
 
     def _ps_mul(self, op, *factors):
-        '''(INTERNAL) Multiply this instance' C{partials} with each
-           of the scalar B{C{factors}} and accumulate.
+        '''(INTERNAL) Multiply this instance' C{partials} with
+           each scalar C{factor} and accumulate into an C{Fsum}.
         '''
         def _pfs(ps, fs):
             if _len(ps) < _len(fs):
@@ -1763,7 +1776,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
                     p *= f
                     yield p if _fin(p) else self._finite(p, op)
 
-        return _Psum(self._ps_acc([], _pfs(self._ps, factors), up=False))
+        return Fsum()._facc_scalar(_pfs(self._ps, factors), up=False)
 
     @property_RO
     def _ps_neg(self):
@@ -1773,7 +1786,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             yield -p
 
     def _ps_1sum(self, *less):
-        '''(INTERNAL) Return the partials sum, 1-primed C{less} any scalars.
+        '''(INTERNAL) Return the partials sum, 1-primed C{less} some scalars.
         '''
         def _1pls(ps, ls):
             yield _1_0
@@ -1800,6 +1813,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
                     return dict(ratio=q, R=t)
         return {}
 
+    rdiv = __rtruediv__
+
     @property_RO
     def real(self):
         '''Get the C{real} part of this instance (C{float}).
@@ -1966,7 +1981,7 @@ class DivMod2Tuple(_NamedTuple):
     _Units_ = (_Float_Int, Fsum)
 
 
-class Fsum2Tuple(_NamedTuple):
+class Fsum2Tuple(_NamedTuple):  # in .fstats
     '''2-Tuple C{(fsum, residual)} with the precision running C{fsum}
        and the C{residual}, the sum of the remaining partials.  Each
        item is C{float} or C{int}.
@@ -2031,7 +2046,7 @@ class Fsum2Tuple(_NamedTuple):
         return self._Fsum._fprs2
 
     @Property_RO
-    def _Fsum(self):  # this C{Fsum2Tuple} as L{Fsum}
+    def _Fsum(self):  # this C{Fsum2Tuple} as L{Fsum}, in .fstats
         s, r = _s_r(*self)
         ps = (r, s) if r else (s,)
         return _Psum(ps, name=self.name)
@@ -2085,7 +2100,7 @@ class Fsum2Tuple(_NamedTuple):
         '''
         return Fmt.PAREN(fstr(self, fmt=fmt, strepr=str, force=False, **prec_sep))
 
-_Fsum_Fsum2Tuple_types = Fsum, Fsum2Tuple  # PYCHOK in .fstats
+_Fsum_Fsum2Tuple_types = Fsum, Fsum2Tuple  # PYCHOK lines
 
 
 class ResidualError(_ValueError):

pygeodesy/interns.py

@@ -332,6 +332,7 @@ _null_                = 'null'               # PYCHOK OK
 _number_              = 'number'             # PYCHOK OK
 _numpy_               = 'numpy'              # PYCHOK OK
 _Nv00_                = 'Nv00'               # PYCHOK OK
+_odd_                 = 'odd'                # PYCHOK OK
 _of_                  = 'of'                 # PYCHOK OK
 _on_                  = 'on'                 # PYCHOK OK
 _opposite_            = 'opposite'           # PYCHOK OK
@@ -647,7 +648,7 @@ def _version_ints(vs):
 __all__ = (_NN_,  # not MISSING!
             Str_.__name__,  # classes
             machine.__name__)  # in .lazily
-__version__ = '24.05.06'
+__version__ = '24.05.08'
 
 if __name__ == '__main__':