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

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,  _xError
-# from pygeodesy.errors import _xError  # from .constants
-from pygeodesy.fmath import hypot2,  sqrt
-from pygeodesy.fsums import _2float, Fsum, _iadd_op_,  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.04.26'
-
-_Floats =  Fsum, 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, ys=False):
+def _2Floats(**xs):
     '''(INTERNAL) Yield each value as C{float} or L{Fsum}.
     '''
-    if ys:
-        def _2f(i, x):
-            return _2float(index=i, ys=x)
-    else:
-        def _2f(i, x):  # PYCHOK redef
-            return _2float(index=i, xs=x)
+    try:
+        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 isinstance(x, _Floats) else _2f(i, 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
 
@@ -86,16 +82,18 @@ class _FstatsNamed(_Named):
         return _NotImplemented(self, other)
 
     def __str__(self):
-        return Fmt.SQUARE(self.named3, len(self))
+        n =  self.name
+        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):
@@ -103,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}.'''
@@ -118,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 isinstance(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):
@@ -207,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
@@ -220,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:
@@ -234,18 +253,19 @@ 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}.
         '''
-        if isinstance(other, Fcook):
+        if _isAn(other, Fcook):
             nb = len(other)
             if nb > 0:
                 na = len(self)
@@ -253,13 +273,13 @@ class Fcook(_FstatsBase):
                     A1, A2, A3, A4 = self._Ms
                     B1, B2, B3, B4 = other._Ms
 
-                    n   = na + nb
-                    n_  = float(n)
-                    D   = A1 - B1  # b1 - a1
-                    Dn  = D / n_
-                    Dn2 = Dn**2  # d**2 / n**2
-                    nab = na * nb
-                    Dn3 = Dn2 * (D * nab)
+                    n   =  na + nb
+                    _n  = _1_0 / n
+                    D   =  A1 - B1  # b1 - a1
+                    Dn  =  D * _n
+                    Dn2 =  Dn**2  # d**2 / n**2
+                    nab =  na * nb
+                    Dn3 =  Dn2 * (D * nab)
 
                     na2 =  na**2
                     nb2 =  nb**2
@@ -269,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 += Dn3 * (na - nb)
+                    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
@@ -291,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>}.
@@ -310,7 +330,7 @@ class Fcook(_FstatsBase):
         n = self._n
         if xs:
             M1, M2, M3, M4 = self._Ms
-            for x in _2Floats(xs):
+            for x in _2Floats(xs=xs):  # PYCHOK yield
                 n1 = n
                 n += 1
                 D  = x - M1
@@ -340,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}).
 
@@ -380,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}).
 
@@ -414,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}).
 
@@ -440,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
 
@@ -476,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}.
@@ -490,19 +539,20 @@ 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}}.
 
            @see: Method L{Fwelford.fadd} and U{Parallel algorithm<https//
                  WikiPedia.org/wiki/Algorithms_for_calculating_variance>}.
         '''
-        if isinstance(other, Fwelford):
+        if _isAn(other, Fwelford):
             nb = len(other)
             if nb > 0:
                 na = len(self)
@@ -510,26 +560,26 @@ class Fwelford(_FstatsBase):
                     M,  S  = self._Ms
                     M_, S_ = other._Ms
 
-                    n  = na + nb
-                    n_ = float(n)
+                    n  =  na + nb
+                    _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
                 else:
                     self._copy(self, other)
 
-        elif isinstance(other, Fcook):
+        elif _isAn(other, Fcook):
             self += other.toFwelford()
         else:
             self._iadd_other(other)
@@ -538,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):
+            for x in _2Floats(xs=xs):  # PYCHOK yield
                 n += 1
                 D  = x - M
                 M += D / n
@@ -573,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)
@@ -596,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}).
 
@@ -609,129 +661,142 @@ class Flinear(_FstatsNamed):
 
            @see: Method L{Flinear.fadd_}.
         '''
-        if isinstance(other, Flinear):
+        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), _2Floats(ys, ys=True)):  # 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)