pygeodesy 24.9.29__py2.py3-none-any.whl → 24.10.10__py2.py3-none-any.whl

pygeodesy/fsums.py

@@ -40,15 +40,14 @@ results may differ from Python's C{math.fsum} results.
 from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import isbool, iscomplex, isint, isscalar, \
-                            _signOf, itemsorted, signOf, _xiterable, \
-                            _xiterablen
+                            _signOf, itemsorted, signOf, _xiterable
 from pygeodesy.constants import INF, INT0, MANT_DIG, NEG0, NINF, _0_0, \
                                _1_0, _N_1_0, _isfinite, _pos_self, \
                                Float, Int
 from pygeodesy.errors import _AssertionError, _OverflowError, _TypeError, \
-                             _ValueError, _xError, _xError2, _xkwds_get, \
-                             _xkwds, _xkwds_get1, _xkwds_not, _xkwds_pop, \
-                             _xsError
+                             _ValueError, _xError, _xError2, _xkwds, \
+                             _xkwds_get, _xkwds_get1, _xkwds_not, \
+                             _xkwds_pop, _xsError
 from pygeodesy.internals import _enquote, _passarg
 from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DOT_, _from_, \
                              _not_finite_, _SPACE_, _std_, _UNDER_
@@ -65,7 +64,7 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '24.09.29'
+__version__ = '24.10.09'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -78,16 +77,13 @@ from pygeodesy.interns import (
   _DASH_     as _sub_op_,  # in .auxilats.auxAngle
   _SLASH_    as _truediv_op_
 )
-_eq_op_       = _fset_op_ * 2  # _DEQUAL_
 _floordiv_op_ = _truediv_op_ * 2  # _DSLASH_
 _divmod_op_   = _floordiv_op_ + _mod_op_
 _F2PRODUCT    = _getenv('PYGEODESY_FSUM_F2PRODUCT', NN)
-_ge_op_       = _gt_op_ + _fset_op_
 _iadd_op_     = _add_op_ + _fset_op_  # in .auxilats.auxAngle, .fstats
 _integer_     = 'integer'
 _isub_op_     = _sub_op_ + _fset_op_  # in .auxilats.auxAngle
-_le_op_       = _lt_op_ + _fset_op_
-_NONFINITEr   = _0_0
+_NONFINITEr   = _0_0  # NOT INT0!
 _NONFINITES   = _getenv('PYGEODESY_FSUM_NONFINITES', NN)
 _non_zero_    = 'non-zero'
 _pow_op_      = _mul_op_ * 2  # _DSTAR_
@@ -96,10 +92,10 @@ _significant_ = 'significant'
 _threshold_   = 'threshold'
 
 
-def _2finite(x):  # in .fstats
+def _2finite(x, _isfine=_isfinite):  # in .fstats
     '''(INTERNAL) return C{float(x)} if finite.
     '''
-    return (float(x) if _isfinite(x)  # and isscalar(x)
+    return (float(x) if _isfine(x)  # and isscalar(x)
             else _nfError(x))
 
 
@@ -114,28 +110,6 @@ def _2float(index=None, _isfine=_isfinite, **name_x):  # in .fmath, .fstats
         raise _xError(X, Fmt.INDEX(n, index), x)
 
 
-def _X_ps(X):  # for _2floats only
-    return X._ps
-
-
-def _2floats(xs, origin=0, _X=_X_ps, _x=float, _isfine=_isfinite):
-    '''(INTERNAL) Yield each B{C{xs}} as a C{float}.
-    '''
-    try:
-        i, x =  origin, xs
-        _FsT = _Fsum_2Tuple_types
-        for x in _xiterable(xs):
-            if isinstance(x, _FsT):
-                for p in _X(x._Fsum):
-                    yield p
-            else:
-                f = _x(x)
-                yield f if _isfine(f) else _nfError(f)
-            i += 1
-    except Exception as X:
-        raise _xsError(X, xs, i, x)
-
-
 try:  # MCCABE 26
     from math import fma as _fma
 
@@ -145,8 +119,9 @@ try:  # MCCABE 26
         # <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
         for y in ys:
             f = x * y
-            yield  f
-            yield _fma(x, y, -f)
+            yield f
+            if _isfinite(f):
+                yield _fma(x, y, -f)
         for z in zs:
             yield z
 
@@ -156,7 +131,7 @@ try:  # MCCABE 26
 except  ImportError:  # PYCHOK DSPACE! Python 3.12-
 
     if _F2PRODUCT and _F2PRODUCT != _std_:
-        # back to PyGeodesy 24.09.09, with _fmaX
+        # backward to PyGeodesy 24.09.09, with _fmaX
 
         def _fma(*a_b_c):  # PYCHOK no cover
             # mimick C{math.fma} from Python 3.13+,
@@ -166,12 +141,13 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
             n += da * db * nc
             d  = da * db * dc
             try:
-                r = float(n / d)
+                n, d = _n_d2(n, d)
+                r    = float(n / d)
             except OverflowError:  # "integer division result too large ..."
                 r = NINF if (_signOf(n, 0) * _signOf(d, 0)) < 0 else INF
             return r if _isfinite(r) else _fmaX(r, *a_b_c)  # "overflow in fma"
 
-        def _2n_d(x):
+        def _2n_d(x):  # PYCHOK no cover
             try:  # int.as_integer_ratio in 3.8+
                 return  x.as_integer_ratio()
             except (AttributeError, OverflowError, TypeError, ValueError):
@@ -188,18 +164,18 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
         _2n_d = None  # redef
 
     def _fmaX(r, *a_b_c):  # like Python 3.13+ I{Modules/mathmodule.c}:
-        # raise a ValueError for a NAN result from non-NAN C{a_b_c}s or
-        # OverflowError for a non-NAN result from all finite C{a_b_c}s.
+        # raise a ValueError for a NAN result from non-NAN C{a_b_c}s or an
+        # OverflowError for a non-NAN non-finite from all finite C{a_b_c}s.
         if isnan(r):
             def _x(x):
                 return not isnan(x)
-        else:
+        else:  # non-NAN non-finite
             _x = _isfinite
         if all(map(_x, a_b_c)):
             raise _nfError(r, unstr(_fma, *a_b_c))
         return r
 
-    def _2products(x, y3s, *zs):  # PYCHOK in Fsum._f2mul
+    def _2products(x, y3s, *zs):  # PYCHOK in _fma, ...
         # yield(x * y3 for y3 in y3s) + yield(z in zs)
         # TwoProduct U{Algorithm 3.3
         # <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
@@ -209,20 +185,16 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
         for y, c, d in y3s:
             y *= x
             yield y
-            if False:  # no cover
-                yield b * d - (((y - a * c) - b * c) - a * d)
-                #   = b * d + (a * d - ((y - a * c) - b * c))
-                #   = b * d + (a * d + (b * c - (y - a * c)))
-                #   = b * d + (a * d + (b * c + (a * c - y)))
-            elif a:
+            if _isfinite(y):
+                # yield b * d - (((y - a * c) - b * c) - a * d)
+                #     = b * d + (a * d - ((y - a * c) - b * c))
+                #     = b * d + (a * d + (b * c - (y - a * c)))
+                #     = b * d + (a * d + (b * c + (a * c - y)))
                 yield a * c - y
                 yield b * c
                 if d:
                     yield a * d
                     yield b * d
-            else:
-                yield b * c - y
-                yield b * d
         for z in zs:
             yield z
 
@@ -268,10 +240,10 @@ def _Fsumf_(*xs):  # in .auxLat, .ltp, ...
 def _Fsum1f_(*xs):  # in .albers
     '''(INTERNAL) An C{Fsum(xs)}, all C{scalar}, an L{Fsum} or L{Fsum2Tuple}, 1-primed.
     '''
-    return Fsum()._facc_scalarf(_1primed(xs), up=False)
+    return Fsum()._facc_scalarf(_1primed(xs), origin=-1, up=False)
 
 
-def _2halfeven(s, r, p):
+def _halfeven(s, r, p):
     '''(INTERNAL) Round half-even.
     '''
     if (p > 0 and r > 0) or \
@@ -302,19 +274,31 @@ def _isOK(unused):
 
 
 def _isOK_or_finite(x, _isfine=_isfinite):
-    '''(INTERNAL) Is C{x} finite or is I{non-finite} OK?.
+    '''(INTERNAL) Is C{x} finite or is I{non-finite} OK?
     '''
     # assert _isfine in (_isOK, _isfinite)
-    return _isfine(x)
+    return _isfine(x)  # C{bool}
 
 
-def _ixError(X, xs, i, x, origin=0, which=None):
-    '''(INTERNAL) Error for C{xs} or C{x}, item C{xs[i]}.
-    '''
-    t = _xsError(X, xs, i + origin, x)
-    if which:
-        t = _COMMASPACE_(unstr(which, _Cdot=Fsum), t)
-    return _xError(X, t, txt=None)
+try:
+    from math import gcd as _gcd
+
+    def _n_d2(n, d):
+        '''(INTERNAL) Reduce C{n} and C{d} by C{gcd}.
+        '''
+        if n and d:
+            try:
+                c = _gcd(n, d)
+                if c > 1:
+                    n, d = (n // c), (d // c)
+            except TypeError:  # non-int float
+                pass
+        return n, d
+
+except ImportError:  # 3.4-
+
+    def _n_d2(*n_d):  # PYCHOK redef
+        return n_d
 
 
 def _nfError(x, *args):
@@ -327,6 +311,13 @@ def _nfError(x, *args):
     raise E(t, txt=None)
 
 
+def _NonfiniteError(x):
+    '''(INTERNAL) Return the Error class for C{x}, I{non-finite}.
+    '''
+    return _OverflowError if isinf(x) else (
+           _ValueError    if isnan(x) else _AssertionError)
+
+
 def nonfiniterrors(*raiser):
     '''Throw C{OverflowError} and C{ValueError} exceptions for or
        handle I{non-finite} C{float}s as C{inf}, C{INF}, C{NINF},
@@ -344,14 +335,8 @@ def nonfiniterrors(*raiser):
     d = Fsum._isfine
     if raiser and raiser[0] is not None:
         Fsum._isfine = {} if bool(raiser[0]) else Fsum._nonfinites_isfine_kwds[True]
-    return _xkwds_get1(d, _isfine=_isfinite) is _isfinite
-
-
-def _NonfiniteError(x):
-    '''(INTERNAL) Return the Error class for C{x}, I{non-finite}.
-    '''
-    return _OverflowError if isinf(x) else (
-           _ValueError    if isnan(x) else _AssertionError)
+    return (False if d is Fsum._nonfinites_isfine_kwds[True] else
+         _xkwds_get1(d, _isfine=_isfinite) is _isfinite) if d else True
 
 
 def _1primed(xs):  # in .fmath
@@ -377,7 +362,7 @@ def _psum(ps, **_isfine):  # PYCHOK used!
             if s:
                 ps[i:] = r, s
                 if i > 0:
-                    s = _2halfeven(s, r, ps[i-1])
+                    s = _halfeven(s, r, ps[i-1])
                 break  # return s
             s = r  # PYCHOK no cover
         elif not _isfinite(s):  # non-finite OK
@@ -404,14 +389,38 @@ def _Psum_(*ps, **name_f2product_nonfinites_RESIDUAL):  # in .fmath
     return _Psum(ps, **name_f2product_nonfinites_RESIDUAL)
 
 
-def _2scalar2(other):
+def _residue(other):
+    '''(INTERNAL) Return the C{residual} or C{None} for C{scalar}.
+    '''
+    try:
+        r = other.residual
+    except AttributeError:
+        r = None  # float, int, other
+    return r
+
+
+def _s_r(s, r):
+    '''(INTERNAL) Return C{(s, r)}, I{ordered}.
+    '''
+    if _isfinite(s):
+        if r:
+            if fabs(s) < fabs(r):
+                s, r = r, (s or INT0)
+        else:
+            r = INT0
+    else:
+        r = _NONFINITEr
+    return s, r
+
+
+def _2s_r(other):
     '''(INTERNAL) Return 2-tuple C{(other, r)} with C{other} as C{int},
-       C{float} or C{as-is} and C{r} the residual of C{as-is}.
+       C{float} or C{as-is} and C{r} the residual of C{as-is} or 0.
     '''
     if _isFsum_2Tuple(other):
         s, r = other._fint2
         if r:
-            s, r = other._fprs2
+            s, r = other._nfprs2
             if r:  # PYCHOK no cover
                 s = other  # L{Fsum} as-is
     else:
@@ -422,17 +431,6 @@ def _2scalar2(other):
     return s, r
 
 
-def _s_r(s, r):
-    '''(INTERNAL) Return C{(s, r)}, I{ordered}.
-    '''
-    if r and _isfinite(s):
-        if fabs(s) < fabs(r):
-            s, r = r, (s or INT0)
-    else:
-        r = INT0
-    return s, r
-
-
 def _strcomplex(s, *args):
     '''(INTERNAL) C{Complex} 2- or 3-arg C{pow} error as C{str}.
     '''
@@ -519,7 +517,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
              C{PYGEODESY_FSUM_NONFINITES} and C{PYGEODESY_FSUM_RESIDUAL}.
     '''
     _f2product = _sys_version_info2 > (3, 12) or bool(_F2PRODUCT)
-    _isfine    = {}  # == _isfinite
+    _isfine    = {}  # == _isfinite, see nonfiniterrors()
     _n         =  0
 #   _ps        = []  # partial sums
 #   _ps_max    =  0  # max(Fsum._ps_max, len(Fsum._ps))  # 41
@@ -560,14 +558,22 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            @see: Methods L{Fsum.fadd_} and L{Fsum.fadd}.
         '''
         f = self._copy_2(self.__add__)
-        return f._fadd(other, _add_op_)
+        return f._fadd(other)
 
     def __bool__(self):  # PYCHOK Python 3+
         '''Return C{bool(B{self})}, C{True} iff C{residual} is zero.
         '''
-        s, r = self._fprs2
+        s, r = self._nfprs2
         return bool(s or r) and s != -r  # == self != 0
 
+    def __call__(self, other, **up):  # in .fmath
+        '''Reset this C{Fsum} to C{other}, default C{B{up}=True}.
+        '''
+        self._ps[:] = 0,  # clear for errors
+        self._fset(other, op=_fset_op_, **up)
+        return self
+
+
     def __ceil__(self):  # PYCHOK not special in Python 2-
         '''Return this instance' C{math.ceil} as C{int} or C{float}.
 
@@ -609,7 +615,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''Return C{(B{self} == B{other})} as C{bool} where B{C{other}}
            is C{scalar}, an other L{Fsum} or L{Fsum2Tuple}.
         '''
-        return self._cmp_0(other, _eq_op_) == 0
+        return self._cmp_0(other, _fset_op_ + _fset_op_) == 0
 
     def __float__(self):
         '''Return this instance' current, precision running sum as C{float}.
@@ -646,7 +652,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __ge__(self, other):
         '''Return C{(B{self} >= B{other})}, see C{__eq__}.
         '''
-        return self._cmp_0(other, _ge_op_) >= 0
+        return self._cmp_0(other, _gt_op_ + _fset_op_) >= 0
 
     def __gt__(self, other):
         '''Return C{(B{self} > B{other})}, see C{__eq__}.
@@ -674,7 +680,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            @see: Methods L{Fsum.fadd_} and L{Fsum.fadd}.
         '''
         try:
-            return self._fadd(other, _iadd_op_)
+            return self._fadd(other, op=_iadd_op_)
         except TypeError:
             pass
         _xiterable(other)
@@ -834,7 +840,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __le__(self, other):
         '''Return C{(B{self} <= B{other})}, see C{__eq__}.
         '''
-        return self._cmp_0(other, _le_op_) <= 0
+        return self._cmp_0(other, _lt_op_ + _fset_op_) <= 0
 
     def __len__(self):
         '''Return the number of values accumulated (C{int}).
@@ -896,7 +902,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            @see: Method L{Fsum.__iadd__}.
         '''
         f = self._copy_2r(other, self.__radd__)
-        return f._fadd(self, _add_op_)
+        return f._fadd(self)
 
     def __rdivmod__(self, other):
         '''Return C{divmod(B{other}, B{self})} as 2-tuple
@@ -1030,9 +1036,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         n, r = self._fint2
         if r:
-            i, d = float(r).as_integer_ratio()
-            n *= d
-            n += i
+            i, d =  float(r).as_integer_ratio()
+            n, d = _n_d2(n * d + i, d)
         else:  # PYCHOK no cover
             d = 1
         return n, d
@@ -1042,7 +1047,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''Get this instance I{as-is} (L{Fsum} with C{non-zero residual},
            C{scalar} or I{non-finite}).
         '''
-        s, r = self._fprs2
+        s, r = self._nfprs2
         return self if r else s
 
     @property_RO
@@ -1089,6 +1094,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             f._n = 1
         # assert f._f2product == self._f2product
         # assert f._Fsum is f
+        # assert f._isfine is self._isfine
+        # assert f._RESIDUAL is self._RESIDUAL
         return f
 
     def _copy_2(self, which, name=NN):
@@ -1101,6 +1108,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         # assert f._n == self._n
         # assert f._f2product == self._f2product
         # assert f._Fsum is f
+        # assert f._isfine is self._isfine
+        # assert f._RESIDUAL is self._RESIDUAL
         return f
 
     def _copy_2r(self, other, which):
@@ -1130,15 +1139,17 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''(INTERNAL) Format the caught exception C{X}.
         '''
         E, t = _xError2(X)
-        u = unstr(self.named3, *xs[:3], _ELLIPSIS=len(xs) > 3, **kwds)
+        u = unstr(self.named3, *xs, _ELLIPSIS=4, **kwds)
         return E(u, txt=t, cause=X)
 
-    def _facc(self, xs, up=True, **origin_X_x):
-        '''(INTERNAL) Accumulate more C{scalars} or L{Fsum}s.
+    def _facc(self, xs, up=True, **_X_x_origin):
+        '''(INTERNAL) Accumulate more C{scalar}s or L{Fsum}s.
         '''
         if xs:
-            kwds  = _xkwds(self._isfine, **origin_X_x)
-            fs    = _2floats(xs, **kwds)  # PYCHOK yield
+            kwds = self._isfine
+            if _X_x_origin:
+                kwds = _xkwds(_X_x_origin, **kwds)
+            fs    = _xs(xs, **kwds)  # PYCHOK yield
             ps    =  self._ps
             ps[:] =  self._ps_acc(list(ps), fs, up=up)
         return self
@@ -1147,8 +1158,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''(INTERNAL) Accumulate 0, 1 or more C{xs}, all positional
            arguments in the caller of this method.
         '''
-        return self._facc(xs, origin=1, **up) if len(xs) != 1 else \
-               self._fadd(xs[0], _add_op_, **up)
+        return self._fadd(xs[0], **up) if len(xs) == 1 else \
+               self._facc(xs, **up)  # origin=1?
 
     def _facc_neg(self, xs, **up_origin):
         '''(INTERNAL) Accumulate more C{xs}, negated.
@@ -1197,7 +1208,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                     f *= _pow(x, r, power, op, **raiser_RESIDUAL)
                 return f
 
-            f = self._facc(xs, origin=1, _X=_P, _x=_p)
+            f = self._facc(xs, _X=_P, _x=_p)  # origin=1?
         else:
             f = self._facc_scalar_(float(len(xs)))  # x**0 == 1
         return f
@@ -1206,7 +1217,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''(INTERNAL) Accumulate all C{xs}, each C{scalar}.
         '''
         if xs:
-            _ = self._ps_acc(self._ps, xs, **up)
+            ps    = self._ps
+            ps[:] = self._ps_acc(list(ps), xs, **up)
         return self
 
     def _facc_scalar_(self, *xs, **up):
@@ -1214,16 +1226,14 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         return self._facc_scalar(xs, **up)
 
-    def _facc_scalarf(self, xs, **origin_which):
+    def _facc_scalarf(self, xs, up=True, **origin_which):
         '''(INTERNAL) Accumulate all C{xs}, each C{scalar}, an L{Fsum} or
            L{Fsum2Tuple}, like function C{_xsum}.
         '''
-        i_x = [0, xs]
-        try:
-            nf = self.nonfinitesOK
-            return self._facc_scalar(_xs(xs, i_x, nf))
-        except (OverflowError, TypeError, ValueError) as X:
-            raise _ixError(X, xs, *i_x, **origin_which)
+        _C =  self.__class__
+        fs = _xs(xs, **_x_isfine(self.nonfinitesOK, _Cdot=_C,
+                               **origin_which))  # PYCHOK yield
+        return self._facc_scalar(fs, up=up)
 
 #   def _facc_up(self, up=True):
 #       '''(INTERNAL) Update the C{partials}, by removing
@@ -1242,8 +1252,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def fadd(self, xs=()):
         '''Add an iterable's items to this instance.
 
-           @arg xs: Iterable of items to add (each C{scalar}
-                    or an L{Fsum} or L{Fsum2Tuple} instance).
+           @arg xs: Iterable of items to add (each C{scalar},
+                    an L{Fsum} or L{Fsum2Tuple}).
 
            @return: This instance (L{Fsum}).
 
@@ -1265,26 +1275,20 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def fadd_(self, *xs):
         '''Add all positional items to this instance.
 
-           @arg xs: Values to add (each C{scalar} or an L{Fsum}
-                    or L{Fsum2Tuple} instance), all positional.
+           @arg xs: Values to add (each C{scalar}, an L{Fsum}
+                    or L{Fsum2Tuple}), all positional.
 
            @see: Method L{Fsum.fadd} for further details.
         '''
         return self._facc_args(xs)
 
-    def _fadd(self, other, op, **up):  # in .fmath.Fhorner
+    def _fadd(self, other, op=_add_op_, **up):
         '''(INTERNAL) Apply C{B{self} += B{other}}.
         '''
         if _isFsum_2Tuple(other):
-            if self._ps:
-                self._facc_scalar(other._ps, **up)
-            else:
-                self._fset(other, op=op, **up)
+            self._facc_scalar(other._ps, **up)
         elif self._scalar(other, op):
-            if self._ps:
-                self._facc_scalar_(other, **up)
-            else:
-                self._fset(other, op=op, **up)
+            self._facc_scalar_(other, **up)
         return self
 
     fcopy   =   copy  # for backward compatibility
@@ -1310,25 +1314,27 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 #               raise self._Error(op, other, _AssertionError, txt__=signOf)
         return DivMod2Tuple(q, self)  # q is C{int} in Python 3+, but C{float} in Python 2-
 
-    def _fhorner(self, x, cs, op, incx=True):  # in .fmath
+    def _fhorner(self, x, cs, where, incx=True):  # in .fmath
         '''(INTERNAL) Add an L{Fhorner} evaluation of polynomial
            C{sum(cs[i] * B{x}**i for i=0..len(cs)-1) if B{incx}
            else sum(... i=len(cs)-1..0)}.
         '''
-        if _xiterablen(cs):
-            H = self._Fsum_as(name__=self._fhorner)
-            if _isFsum_2Tuple(x):
-                _mul = H._mul_Fsum
-            else:
-                _mul = H._mul_scalar
-                x = _2float(x=x, **self._isfine)
-            if len(cs) > 1 and x:
+        # assert _xiterablen(cs)
+        try:
+            n  = len(cs)
+            H  = self._Fsum_as(name__=self._fhorner)
+            _m = H._mul_Fsum if _isFsum_2Tuple(x) else \
+                 H._mul_scalar
+            if _2finite(x, **self._isfine) and n > 1:
                 for c in (reversed(cs) if incx else cs):
-                    H._fset_ps(_mul(x, op))
-                    H._fadd(c, op, up=False)
+                    H._fset(_m(x, _mul_op_), up=False)
+                    H._fadd(c, up=False)
             else:  # x == 0
-                H = cs[0] if cs else _0_0
-            self._fadd(H, op)
+                H = cs[0] if n else 0
+            self._fadd(H)
+        except Exception as X:
+            t = unstr(where, x, *cs, _ELLIPSIS=4, incx=incx)
+            raise self._ErrorX(X, _add_op_, t)
         return self
 
     def _finite(self, other, op=None):
@@ -1380,36 +1386,28 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _fint2(self):  # see ._fset
         '''(INTERNAL) Get 2-tuple (C{int}, I{integer} residual).
         '''
-        s, _ = self._fprs2
-        try:
+        s, r = self._nfprs2
+        if _isfinite(s):
             i =  int(s)
             r = (self._ps_1sum(i) if len(self._ps) > 1 else
                  float(s - i)) or INT0
-        except (OverflowError, ValueError) as X:
-            r = _NONFINITEr  # INF, NAN, NINF
-            i =  self._fintX(X, sum(self._ps))
+        else:  # INF, NAN, NINF
+            i =  float(s)
+#           r = _NONFINITEr
         return i, r  # Fsum2Tuple?
 
     @_fint2.setter_  # PYCHOK setter_UNDERscore!
     def _fint2(self, s):  # in _fset
         '''(INTERNAL) Replace the C{_fint2} value.
         '''
-        try:
+        if _isfinite(s):
             i =  int(s)
             r = (s - i) or INT0
-        except (OverflowError, ValueError) as X:
-            r = _NONFINITEr  # INF, NAN, NINF
-            i =  self._fintX(X, float(s))
+        else:  # INF, NAN, NINF
+            i =  float(s)
+            r = _NONFINITEr
         return i, r  # like _fint2.getter
 
-    def _fintX(self, X, i):  # PYCHOK X
-        '''(INTERNAL) Handle I{non-finite} C{int}.
-        '''
-        # "cannot convert float infinity to integer"
-        return i  # ignore such Overflow-/ValueErrors
-        # op = int.__name__
-        # return self._nonfiniteX(X, op, i)
-
     @deprecated_property_RO
     def float_int(self):  # PYCHOK no cover
         '''DEPRECATED, use method C{Fsum.int_float}.'''
@@ -1456,16 +1454,19 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             if r:
                 f  =  self._f2mul(self.fma, other1, **nonfinites)
                 f +=  other2
-            else:
+            elif _residue(other1) or _residue(other2):
                 fs = _2split3s(_fs(op, other1))
                 fs = _2products(s, fs, *_fs(op, other2))
                 f  = _Psum(self._ps_acc([], fs, up=False), name=op)
+            else:
+                f  = _fma(s, other1, other2)
+                f  = _2finite(f, **self._isfine)
         except TypeError as X:
             raise self._ErrorX(X, op, (other1, other2))
         except (OverflowError, ValueError) as X:  # from math.fma
-            f = self._mul_reduce(op, s, other1)  # INF, NAN, NINF
-            f = sum(_fs(op, f, other2))
-            f = self._nonfiniteX(X, op, f, **nonfinites)
+            f  = self._mul_reduce(s, other1)  # INF, NAN, NINF
+            f += sum(_fs(op, other2))
+            f  = self._nonfiniteX(X, op, f, **nonfinites)
         return self._fset(f)
 
     fmul = __imul__
@@ -1524,7 +1525,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             except TypeError as X:
                 raise self._ErrorX(X, op, other)
             except (OverflowError, ValueError) as X:
-                r = self._mul_reduce(op, sum(ps), other)  # INF, NAN, NINF
+                r = self._mul_reduce(sum(ps), other)  # INF, NAN, NINF
                 r = self._nonfiniteX(X, op, r, **nonfinites_raiser)
                 f._fset(r)
         return f
@@ -1557,7 +1558,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             elif self.is_integer():
                 # return an exact C{int} for C{int}**C{int}
                 i, _ =  self._fint2  # assert _ == 0
-                x, r = _2scalar2(other)  # C{int}, C{float} or other
+                x, r = _2s_r(other)  # C{int}, C{float} or other
                 f = self._Fsum_as(i)._pow_Fsum(other, op, **raiser_RESIDUAL) if r else \
                     self._pow_2_3(i, x,        other, op, **raiser_RESIDUAL)
             else:  # mod[0] is None, power(self, other)
@@ -1631,10 +1632,11 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                 s = ps[0]
                 r = INT0 if _isfinite(s) else _NONFINITEr
             else:  # len(ps) == 0
-                s, r = _0_0, INT0
+                s = _0_0
+                r = INT0 if _isfinite(s) else _NONFINITEr
                 ps[:] = s,
         except (OverflowError, ValueError) as X:
-            op = sum.__name__  # INF, NAN, NINF
+            op = _fset_op_  # INF, NAN, NINF
             ps[:] = sum(ps),  # collapse ps
             s =  self._nonfiniteX(X, op, ps[0])
             r = _NONFINITEr
@@ -1658,8 +1660,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.fadd} for further details.
         '''
-        f = self._Fsum_as(*xs)
-        return self._fset(f, up=False, op=_fset_op_)
+        f = (xs[0] if xs else _0_0) if len(xs) < 2 else \
+            Fsum(*xs, nonfinites=self.nonfinites())  # self._Fsum_as(*xs)
+        return self._fset(f, op=_fset_op_)
 
     def _fset(self, other, n=0, up=True, **op):
         '''(INTERNAL) Overwrite this instance with an other or a C{scalar}.
@@ -1667,6 +1670,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         if other is self:
             pass  # from ._fmul, ._ftruediv and ._pow_0_1
         elif _isFsum_2Tuple(other):
+            if op:  # and not self.nonfinitesOK:
+                self._finite(other._fprs, **op)
             self._ps[:] = other._ps
             self._n     = n or other._n
             if up:  # use or zap the C{Property_RO} values
@@ -1689,11 +1694,6 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             raise self._Error(op, other, _TypeError)
         return self
 
-    def _fset_ps(self, other):  # in .fmath._Fsum__init__
-        '''(INTERNAL) Set partials from a known C{other}.
-        '''
-        return self._fset(other, up=False)
-
     def fsub(self, xs=()):
         '''Subtract an iterable's items from this instance.
 
@@ -1706,8 +1706,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.fadd_} for further details.
         '''
-        return self._facc_neg(xs, origin=1) if len(xs) != 1 else \
-               self._fsub(xs[0], _sub_op_)
+        return self._fsub(xs[0], _sub_op_) if len(xs) == 1 else \
+               self._facc_neg(xs)  # origin=1?
 
     def _fsub(self, other, op):
         '''(INTERNAL) Apply C{B{self} -= B{other}}.
@@ -1725,8 +1725,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''Add an iterable's items, summate and return the current
            precision running sum.
 
-           @arg xs: Iterable of items to add (each item C{scalar}
-                    or an L{Fsum} or L{Fsum2Tuple} instance).
+           @arg xs: Iterable of items to add (each item C{scalar},
+                    an L{Fsum} or L{Fsum2Tuple}).
 
            @return: Precision running sum (C{float} or C{int}).
 
@@ -1740,8 +1740,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''Add any positional items, summate and return the current
            precision running sum.
 
-           @arg xs: Items to add (each C{scalar} or an L{Fsum}
-                    or L{Fsum2Tuple} instance), all positional.
+           @arg xs: Items to add (each C{scalar}, an L{Fsum} or
+                    L{Fsum2Tuple}), all positional.
 
            @return: Precision running sum (C{float} or C{int}).
 
@@ -1765,10 +1765,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @return: Precision running sum (L{Fsum2Tuple}).
         '''
-        return Fsum2Tuple(self._facc_args(xs)._fprs2, **name)
+        return Fsum2Tuple(self._facc_args(xs)._nfprs2, **name)
 
     @property_RO
-    def _Fsum(self):  # like L{Fsum2Tuple._Fsum}, for C{_2floats}, .fstats
+    def _Fsum(self):  # like L{Fsum2Tuple._Fsum}, in .fstats
         return self  # NOT @Property_RO, see .copy and ._copy_2
 
     def _Fsum_as(self, *xs, **name_f2product_nonfinites_RESIDUAL):
@@ -1782,17 +1782,17 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                                                 RESIDUAL  =self.RESIDUAL())
         if name_f2product_nonfinites_RESIDUAL:  # overwrites
             kwds.update(name_f2product_nonfinites_RESIDUAL)
-        F = Fsum(**kwds)
-        # assert all(v == self.__dict__[n] for n, v in F.__dict__.items())
-        return F._fset(xs[0], op=_fset_op_) if len(xs) == 1 else (
-               F._facc(xs, up=False) if xs else F)
+        f = Fsum(**kwds)
+        # assert all(v == self.__dict__[n] for n, v in f.__dict__.items())
+        return f._fset(xs[0], op=_fset_op_) if len(xs) == 1 else (
+               f._facc(xs, up=False) if xs else f)
 
     def fsum2(self, xs=(), **name):
         '''Add an iterable's items, summate and return the
            current precision running sum I{and} the C{residual}.
 
-           @arg xs: Iterable of items to add (each item C{scalar}
-                    or an L{Fsum} or L{Fsum2Tuple} instance).
+           @arg xs: Iterable of items to add (each item C{scalar},
+                    an L{Fsum} or L{Fsum2Tuple}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: L{Fsum2Tuple}C{(fsum, residual)} with C{fsum} the
@@ -1810,8 +1810,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''Add any positional items, summate and return the current
            precision running sum and the I{differential}.
 
-           @arg xs: Values to add (each C{scalar} or an L{Fsum} or
-                    L{Fsum2Tuple} instance), all positional.
+           @arg xs: Values to add (each C{scalar}, an L{Fsum} or
+                    L{Fsum2Tuple}), all positional.
 
            @return: 2Tuple C{(fsum, delta)} with the current, precision
                     running C{fsum} like method L{Fsum.fsum} and C{delta},
@@ -1838,19 +1838,19 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''Like method L{Fsum.fsum_} iff I{all} C{B{xs}}, each I{known to be}
            C{scalar}, an L{Fsum} or L{Fsum2Tuple}.
         '''
-        return self._facc_scalarf(xs, origin=1, which=self.fsumf_)._fprs
+        return self._facc_scalarf(xs, which=self.fsumf_)._fprs  # origin=1?
 
     def Fsumf_(self, *xs):
         '''Like method L{Fsum.Fsum_} iff I{all} C{B{xs}}, each I{known to be}
            C{scalar}, an L{Fsum} or L{Fsum2Tuple}.
         '''
-        return self._facc_scalarf(xs, origin=1, which=self.Fsumf_)._copy_2(self.Fsumf_)
+        return self._facc_scalarf(xs, which=self.Fsumf_)._copy_2(self.Fsumf_)  # origin=1?
 
     def fsum2f_(self, *xs):
         '''Like method L{Fsum.fsum2_} iff I{all} C{B{xs}}, each I{known to be}
            C{scalar}, an L{Fsum} or L{Fsum2Tuple}.
         '''
-        return self._fsum2(xs, self._facc_scalarf, origin=1, which=self.fsum2f_)
+        return self._fsum2(xs, self._facc_scalarf, which=self.fsum2f_)  # origin=1?
 
 #   ftruediv = __itruediv__   # for naming consistency?
 
@@ -1891,8 +1891,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                          L{ResidualError}s (C{bool}) and C{B{RESIDUAL}=scalar}
                          to override the current L{RESIDUAL<Fsum.RESIDUAL>}.
 
-           @return: This C{int} sum if this instance C{is_integer}, otherwise
-                    the C{float} sum if the residual is zero or not significant.
+           @return: This C{int} sum if this instance C{is_integer} and
+                    I{finite}, otherwise the C{float} sum if the residual
+                    is zero or not significant.
 
            @raise ResidualError: Non-zero, significant residual or invalid
                                  B{C{RESIDUAL}}.
@@ -1951,48 +1952,52 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         return _sum is _fsum  # _fsum.__module__ is fabs.__module__
 
     def is_scalar(self, **raiser_RESIDUAL):
-        '''Is this instance' running sum C{scalar} without residual or with
+        '''Is this instance' running sum C{scalar} with C{0} residual or with
            a residual I{ratio} not exceeding the RESIDUAL threshold?
 
            @kwarg raiser_RESIDUAL: Use C{B{raiser}=False} to ignore
                          L{ResidualError}s (C{bool}) and C{B{RESIDUAL}=scalar}
                          to override the current L{RESIDUAL<Fsum.RESIDUAL>}.
 
-           @return: C{True} if this instance' non-zero residual C{ratio} exceeds
-                    the L{RESIDUAL<Fsum.RESIDUAL>} threshold (C{bool}).
+           @return: C{True} if this instance' residual is C{0} or C{insignificant},
+                    i.e. its residual C{ratio} doesn't exceed the L{RESIDUAL
+                    <Fsum.RESIDUAL>} threshold (C{bool}).
 
            @raise ResidualError: Non-zero, significant residual or invalid
                                  B{C{RESIDUAL}}.
 
-           @see: Method L{Fsum.RESIDUAL}, L{Fsum.is_integer} and property
+           @see: Methods L{Fsum.RESIDUAL} and L{Fsum.is_integer} and property
                  L{Fsum.as_iscalar}.
         '''
         s, r = self._fprs2
         return False if r and self._raiser(r, s, **raiser_RESIDUAL) else True
 
-    def _mul_Fsum(self, other, op=_mul_op_):  # in .fmath.Fhorner
+    def _mul_Fsum(self, other, op):
         '''(INTERNAL) Return C{B{self} * B{other}} as L{Fsum} or C{0}.
         '''
         # assert _isFsum_2Tuple(other)
         if self._ps and other._ps:
-            f =  self._ps_mul(op, *other._ps)  # NO .as_iscalar!
+            try:
+                f = self._ps_mul(op, *other._ps)  # NO .as_iscalar!
+            except Exception as X:
+                raise self._ErrorX(X, op, other)
         else:
             f = _0_0
         return f
 
-    def _mul_reduce(self, op, start, *others):
-        '''(INTERNAL) Like fmath.freduce(_operator.mul, ...)
-           for I{non-finite} C{start} and/or C{others}.
+    def _mul_reduce(self, *others):
+        '''(INTERNAL) Like fmath.fprod for I{non-finite} C{other}s.
         '''
-        for p in self._ps_other(op, *others):
-            start *= p
-        return start
+        r = _1_0
+        for f in others:
+            r *= sum(f._ps) if _isFsum_2Tuple(f) else float(f)
+        return r
 
-    def _mul_scalar(self, factor, op):  # in .fmath.Fhorner
+    def _mul_scalar(self, factor, op):
         '''(INTERNAL) Return C{B{self} * scalar B{factor}} as L{Fsum}, C{0.0} or C{self}.
         '''
         # assert isscalar(factor)
-        if self._ps and self._finite(factor, op):
+        if self._ps and self._finite(factor, op=op):
             f =  self      if factor == _1_0   else (
                  self._neg if factor == _N_1_0 else
                  self._ps_mul(op, factor).as_iscalar)
@@ -2011,6 +2016,16 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         return _Psum(self._ps_neg) if self._ps else NEG0
 
+    @property_RO
+    def _nfprs2(self):
+        '''(INTERNAL) Handle I{non-finite} C{_fprs2}.
+        '''
+        try:  # to handle nonfiniterrors, etc.
+            t = self._fprs2
+        except (OverflowError, ValueError):
+            t = Fsum2Tuple(sum(self._ps), _NONFINITEr)
+        return t
+
     def nonfinites(self, *OK):
         '''Handle I{non-finite} C{float}s as C{inf}, C{INF}, C{NINF}, C{nan}
            and C{NAN} for this L{Fsum} or throw C{OverflowError} respectively
@@ -2048,10 +2063,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def nonfinitesOK(self):
         '''Are I{non-finites} C{OK} for this L{Fsum} or by default? (C{bool}).
         '''
-        nf = self.nonfinites()
-        if nf is None:
-            nf = not nonfiniterrors()
-        return nf
+#       nf = self.nonfinites()
+#       if nf is None:
+#           nf = not nonfiniterrors()
+        return _isOK_or_finite(INF, **self._isfine)
 
     def _nonfiniteX(self, X, op, f, nonfinites=None, raiser=None):
         '''(INTERNAL) Handle a I{non-finite} exception.
@@ -2122,7 +2137,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         if _isFsum_2Tuple(other):
             f = self._pow_Fsum(other, op, **raiser_RESIDUAL)
         elif self._scalar(other, op):
-            x = self._finite(other, op)
+            x = self._finite(other, op=op)
             f = self._pow_scalar(x, other, op, **raiser_RESIDUAL)
         else:
             f = self._pow_0_1(0, other)
@@ -2149,7 +2164,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                 return s
 
             b = _s(*(b._fprs2 if m is None else b._fint2))
-            x = _s(*_2scalar2(x))
+            x = _s(*_2s_r(x))
 
         try:
             # 0**INF == 0.0, 1**INF == 1.0, -1**2.3 == -(1**2.3)
@@ -2157,7 +2172,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             if iscomplex(s):
                 # neg**frac == complex in Python 3+, but ValueError in 2-
                 raise ValueError(_strcomplex(s, b, x, *mod))
-            return self._finite(s)
+            _ = _2finite(s, **self._isfine)  # ignore float
+            return s
         except Exception as X:
             raise self._ErrorX(X, op, other, *mod)
 
@@ -2258,13 +2274,12 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                 n += 1
         if n:
             self._n += n
-#           if _fi:  # collapse ps if non-finite
-#               x = sum(ps)
-#               if not _isfinite(x):
-#                   ps[:] = x,
             # Fsum._ps_max = max(Fsum._ps_max, len(ps))
             if up:
                 self._update()
+#               x = sum(ps)
+#               if not _isOK_or_finite(x, **fi):
+#                   ps[:] = x,  # collapse ps
         return ps
 
     def _ps_mul(self, op, *factors):
@@ -2285,7 +2300,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
             for p in ps:
                 for f in _pfs(p, fs):
-                    yield f if _isfine(f) else self._finite(f, op)
+                    yield f if _isfine(f) else _nfError(f)
 
         fs = _psfs(self._ps, factors, **self._isfine)
         f  = _Psum(self._ps_acc([], fs, up=False), name=op)
@@ -2298,15 +2313,14 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         for p in self._ps:
             yield -p
 
-    def _ps_other(self, op, *others):
-        '''(INTERNAL) Yield all C{other}s as C{scalar}.
+    def _ps_other(self, op, other):
+        '''(INTERNAL) Yield C{other} as C{scalar}s.
         '''
-        for other in others:
-            if _isFsum_2Tuple(other):
-                for p in other._ps:
-                    yield p
-            else:
-                yield self._scalar(other, op)
+        if _isFsum_2Tuple(other):
+            for p in other._ps:
+                yield p
+        else:
+            yield self._scalar(other, op)
 
     def _ps_1sum(self, *less):
         '''(INTERNAL) Return the partials sum, 1-primed C{less} some scalars.
@@ -2434,7 +2448,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @return: The sign (C{int}, -1, 0 or +1).
         '''
-        s, r = self._fprs2
+        s, r = self._nfprs2
         r = (-r) if res else 0
         return _signOf(s, r)
 
@@ -2462,7 +2476,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         if lenc:
             p = Fmt.SQUARE(p, len(self))
         n = _enquote(self.name, white=_UNDER_)
-        t =  self._fprs2.toStr(**prec_sep_fmt)
+        t =  self._nfprs2.toStr(**prec_sep_fmt)
         return NN(p, _SPACE_, n, t)
 
     def _truediv(self, other, op, **raiser_RESIDUAL):
@@ -2697,7 +2711,7 @@ def fsum_(*xs, **nonfinites):
 
        @see: Function L{fsum<fsums.fsum>} for further details.
     '''
-    return _xsum(fsum_, xs, origin=1, **nonfinites) if xs else _0_0
+    return _xsum(fsum_, xs, **nonfinites) if xs else _0_0  # origin=1?
 
 
 def fsumf_(*xs):
@@ -2708,7 +2722,7 @@ def fsumf_(*xs):
 
        @see: Function L{fsum_<fsums.fsum_>} for further details.
     '''
-    return _xsum(fsumf_, xs, nonfinites=True, origin=1) if xs else _0_0
+    return _xsum(fsumf_, xs, nonfinites=True) if xs else _0_0  # origin=1?
 
 
 def fsum1(xs, **nonfinites):
@@ -2730,7 +2744,7 @@ def fsum1_(*xs, **nonfinites):
 
        @see: Function L{fsum_<fsums.fsum_>} for further details.
     '''
-    return _xsum(fsum1_, xs, origin=1, primed=1, **nonfinites) if xs else _0_0
+    return _xsum(fsum1_, xs, primed=1, **nonfinites) if xs else _0_0  # origin=1?
 
 
 def fsum1f_(*xs):
@@ -2742,34 +2756,48 @@ def fsum1f_(*xs):
     return _xsum(fsum1f_, xs, nonfinites=True, primed=1) if xs else _0_0
 
 
-def _xs(xs, i_x, nfOK):  # in Fsum._facc_scalarf
-    '''(INTERNAL) Yield all C{xs} as C{scalar}.
-    '''
-    _x = _passarg if nfOK else _2finite
-    for i, x in enumerate(xs):
-        i_x[:] = i, x
-        if _isFsum_2Tuple(x):
-            for p in map(_x, x._ps):
-                yield p
-        else:
-            yield _x(x)
+def _x_isfine(nfOK, **kwds):  # get the C{_x} and C{_isfine} handlers.
+    _x_kwds = dict(_x=     (_passarg if nfOK else _2finite),
+                   _isfine=(_isOK    if nfOK else _isfinite))  # PYCHOK kwds
+    _x_kwds.update(kwds)
+    return _x_kwds
 
 
-def _xsum(which, xs, nonfinites=None, origin=0, primed=0, **floats):
-    '''(INTERNAL) Precision summation of C{xs} with conditions.
+def _X_ps(X):  # default C{_X} handler
+    return X._ps  # lambda X: X._ps
+
+
+def _xs(xs, _X=_X_ps, _x=float, _isfine=_isfinite,  # defaults for Fsum._facc
+                        origin=0, which=None, **_Cdot):
+    '''(INTERNAL) Yield each C{xs} item as 1 or more C{float}s.
     '''
-    i_x = [0, xs]
+    i, x = 0, xs
     try:
-        if floats:  # for backward compatibility
-            nonfinites = _xkwds_get1(floats, floats=nonfinites)
-        elif nonfinites is None:
-            nonfinites =  not nonfiniterrors()
-        fs = _xs(xs, i_x, nonfinites)
-        return _fsum(_1primed(fs) if primed else fs)
+        for i, x in enumerate(_xiterable(xs)):
+            if isinstance(x, _Fsum_2Tuple_types):
+                for p in _X(x):
+                    yield p if _isfine(p) else _nfError(p)
+            else:
+                f = _x(x)
+                yield f if _isfine(f) else _nfError(f)
+
     except (OverflowError, TypeError, ValueError) as X:
-        origin -= 1 if primed else 0
-        i_x    += [origin, which]
-        raise _ixError(X, xs, *i_x)
+        t = _xsError(X, xs, i + origin, x)
+        if which:  # prefix invokation
+            w =  unstr(which, *xs, _ELLIPSIS=4, **_Cdot)
+            t = _COMMASPACE_(w, t)
+        raise _xError(X, t, txt=None)
+
+
+def _xsum(which, xs, nonfinites=None, primed=0, **floats):  # origin=0
+    '''(INTERNAL) Precision summation of C{xs} with conditions.
+    '''
+    if floats:  # for backward compatibility
+        nonfinites = _xkwds_get1(floats, floats=nonfinites)
+    elif nonfinites is None:
+        nonfinites =  not nonfiniterrors()
+    fs = _xs(xs, **_x_isfine(nonfinites, which=which))
+    return _fsum(_1primed(fs) if primed else fs)
 
 
 # delete all decorators, etc.