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

pygeodesy/fsums.py

@@ -40,14 +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
+                             _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_
@@ -64,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.25'
+__version__ = '24.10.09'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -77,90 +77,62 @@ 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_
-_NONFINITES   = _getenv('PYGEODESY_FSUM_NONFINITES', NN) == _std_
+_NONFINITEr   = _0_0  # NOT INT0!
+_NONFINITES   = _getenv('PYGEODESY_FSUM_NONFINITES', NN)
 _non_zero_    = 'non-zero'
 _pow_op_      = _mul_op_ * 2  # _DSTAR_
 _RESIDUAL_0_0 = _getenv('PYGEODESY_FSUM_RESIDUAL', _0_0)
 _significant_ = 'significant'
-_2split3s     = _passarg
 _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))
 
 
-def _2float(index=None, _isfine=_isfinite, **name_value):  # in .fmath, .fstats
-    '''(INTERNAL) Raise C{TypeError} or C{ValueError} if not scalar or infinite.
+def _2float(index=None, _isfine=_isfinite, **name_x):  # in .fmath, .fstats
+    '''(INTERNAL) Raise C{TypeError} or C{Overflow-/ValueError} if not finite.
     '''
-    n, v = name_value.popitem()  # _xkwds_item2(name_value)
+    n, x = name_x.popitem()  # _xkwds_item2(name_x)
     try:
-        f = float(v)
-        return f if _isfine(f) else _nfError(f)
+        f = float(x)
+        return f if _isfine(f) else _nfError(x)
     except Exception as X:
-        raise _xError(X, Fmt.INDEX(n, index), v)
+        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_Fsum2Tuple_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 17
+try:  # MCCABE 26
     from math import fma as _fma
-except ImportError:  # Python 3.12-
 
-    if _F2PRODUCT == _std_:
-        _2FACTOR = pow(2, (MANT_DIG + 1) // 2) + 1
+    def _2products(x, ys, *zs):
+        # yield(x * y for y in ys) + yield(z in zs)
+        # TwoProductFMA U{Algorithm 3.5
+        # <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
+        for y in ys:
+            f = x * y
+            yield f
+            if _isfinite(f):
+                yield _fma(x, y, -f)
+        for z in zs:
+            yield z
 
-        def _fma(a, b, c):
-            # mimick C{math.fma} from Python 3.13+,
-            # the same accuracy, but ~13x slower
-            b3s = _2split3(b),
-            r   =  fsumf_(c, *_2products(a, b3s))  # two=True
-            return r if _isfinite(r) else _fmaX(r, a, b, c)
+#   _2split3  = \
+    _2split3s = _passarg  # in Fsum.is_math_fma
 
-        def _2split3(x):
-            # Split U{Algorithm 3.2
-            # <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
-            a  = c = x * _2FACTOR
-            a -= c - x
-            b  = x - a
-            return x, a, b
+except  ImportError:  # PYCHOK DSPACE! Python 3.12-
 
-        def _2split3s(xs):  # overwrites
-            return tuple(map(_2split3, xs))
+    if _F2PRODUCT and _F2PRODUCT != _std_:
+        # backward to PyGeodesy 24.09.09, with _fmaX
 
-    else:
         def _fma(*a_b_c):  # PYCHOK no cover
             # mimick C{math.fma} from Python 3.13+,
             # the same accuracy, but ~14x slower
@@ -169,61 +141,75 @@ except ImportError:  # 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):
                 return (x if isint(x) else float(x)), 1
+    else:
+
+        def _fma(a, b, c):  # PYCHOK redef
+            # mimick C{math.fma} from Python 3.13+,
+            # the same accuracy, but ~13x slower
+            b3s = _2split3(b),  # 1-tuple of 3-tuple
+            r   = _fsum(_2products(a, b3s, c))
+            return r if _isfinite(r) else _fmaX(r, a, b, c)
+
+        _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 _is(x):
+            def _x(x):
                 return not isnan(x)
-        else:
-            _is = _isfinite
-        if all(map(_is, a_b_c)):
+        else:  # non-NAN non-finite
+            _x = _isfinite
+        if all(map(_x, a_b_c)):
             raise _nfError(r, unstr(_fma, *a_b_c))
         return r
 
-if _2split3s is _passarg:  # math._fma or _fma(*a_b_c)
-
-    def _2products(x, ys, **unused):
-        # TwoProductFMA U{Algorithm 3.5
-        # <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
-        for y in ys:
-            f = x * y
-            yield  f
-            yield _fma(x, y, -f)
-
-else:  # in _std_ _fma(a, b, c)
-
-    def _2products(x, y3s, two=False):  # PYCHOK redef
+    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>}
-        # also in Python 3.13+ C{Modules/marhmodule.c} under
+        # also in Python 3.13+ C{Modules/mathmodule.c} under
         # #ifndef UNRELIABLE_FMA ... #else ... #endif
         _, a, b = _2split3(x)
         for y, c, d in y3s:
             y *= x
             yield y
-            if two:  # or not a:
-                yield b * d - (((y - a * c) - b * c) - a * d)
-                #   = b * d + (a * d - ((y - a * c) - b * c))
-                #   = b * d + (a * d + (b * c - (y - a * c)))
-                #   = b * d + (a * d + (b * c + (a * c - y)))
-            else:
+            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
+        for z in zs:
+            yield z
+
+    _2FACTOR = pow(2, (MANT_DIG + 1) // 2) + _1_0  # 134217729 if MANT_DIG == 53
+
+    def _2split3(x):
+        # Split U{Algorithm 3.2
+        # <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
+        a  = c = x * _2FACTOR
+        a -= c - x
+        b  = x - a
+        return x, a, b
+
+    def _2split3s(xs):  # in Fsum.is_math_fma
+        return map(_2split3, xs)
 
 
 def f2product(*two):
@@ -246,18 +232,18 @@ def f2product(*two):
 
 
 def _Fsumf_(*xs):  # in .auxLat, .ltp, ...
-    '''(INTERNAL) An C{Fsum} of I{known scalars}.
+    '''(INTERNAL) An C{Fsum(xs)}, all C{scalar}, an L{Fsum} or L{Fsum2Tuple}.
     '''
-    return Fsum()._facc_scalar(xs, up=False)
+    return Fsum()._facc_scalarf(xs, up=False)
 
 
 def _Fsum1f_(*xs):  # in .albers
-    '''(INTERNAL) An C{Fsum} of I{known scalars}, 1-primed.
+    '''(INTERNAL) An C{Fsum(xs)}, all C{scalar}, an L{Fsum} or L{Fsum2Tuple}, 1-primed.
     '''
-    return Fsum()._facc_scalar(_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 \
@@ -275,23 +261,44 @@ def _isFsum(x):  # in .fmath
     return isinstance(x, Fsum)
 
 
-def _isFsumTuple(x):  # in .basics, .constants, .fmath, .fstats
+def _isFsum_2Tuple(x):  # in .basics, .constants, .fmath, .fstats
     '''(INTERNAL) Is C{x} an C{Fsum} or C{Fsum2Tuple} instance?
     '''
-    return isinstance(x, _Fsum_Fsum2Tuple_types)
+    return isinstance(x, _Fsum_2Tuple_types)
 
 
 def _isOK(unused):
-    '''(INTERNAL) Helper for C{nonfiniterrors} and C{Fsum.nonfinites}.
+    '''(INTERNAL) Helper for C{Fsum._fsum2} and C{Fsum.nonfinites}.
     '''
     return True
 
 
 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}
+
+
+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):
@@ -299,11 +306,18 @@ def _nfError(x, *args):
     '''
     E = _NonfiniteError(x)
     t =  Fmt.PARENSPACED(_not_finite_, x)
-    if args:  # in _fma, _2sum
+    if args:  # in _fmaX, _2sum
         return E(txt=t, *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},
@@ -321,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
@@ -354,13 +362,13 @@ 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
             i = 0  # collapse ps
             if ps:
-                s += _sum(ps)  # _fsum(ps)
+                s += sum(ps)
         ps[i:] = s,
     return s
 
@@ -381,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 _isFsumTuple(other):
+    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:
@@ -399,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}.
     '''
@@ -447,9 +468,9 @@ def _2sum(a, b, _isfine=_isfinite):  # in .testFmath
         else:
             r = (a - s) + b
     elif _isfine(s):
-        r = 0
+        r = _NONFINITEr
     else:  # non-finite and not OK
-        t = unstr(_2sum, a, b)
+        t =  unstr(_2sum, a, b)
         raise _nfError(s, t)
     return s, r
 
@@ -477,10 +498,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
               i.e. any C{type} having method C{__float__}.
 
        @note: Handling of I{non-finites} as C{inf}, C{INF}, C{NINF}, C{nan} and C{NAN} is
-              determined globally by function L{nonfiniterrors<fsums.nonfiniterrors>} and
-              by method L{nonfinites<Fsum.nonfinites>} for individual C{Fsum} instances,
-              overruling the global setting.  By default and for backward compatibility,
-              I{non-finites} raise exceptions.
+              determined by function L{nonfiniterrors<fsums.nonfiniterrors>} for the default
+              and by method L{nonfinites<Fsum.nonfinites>} for individual C{Fsum} instances,
+              overruling the default.  For backward compatibility, I{non-finites} raise
+              exceptions by default.
 
        @see: U{Hettinger<https://GitHub.com/ActiveState/code/tree/master/recipes/Python/
              393090_Binary_floating_point_summatiaccurate_full/recipe-393090.py>},
@@ -496,10 +517,10 @@ 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))
+#   _ps_max    =  0  # max(Fsum._ps_max, len(Fsum._ps))  # 41
     _RESIDUAL  = _threshold(_RESIDUAL_0_0)
 
     def __init__(self, *xs, **name_f2product_nonfinites_RESIDUAL):
@@ -537,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}.
 
@@ -586,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}.
@@ -623,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__}.
@@ -651,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)
@@ -811,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}).
@@ -873,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
@@ -1007,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
@@ -1019,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
@@ -1043,7 +1071,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _cmp_0(self, other, op):
         '''(INTERNAL) Return C{scalar(self - B{other})} for 0-comparison.
         '''
-        if _isFsumTuple(other):
+        if _isFsum_2Tuple(other):
             s = self._ps_1sum(*other._ps)
         elif self._scalar(other, op):
             s = self._ps_1sum(other)
@@ -1066,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):
@@ -1078,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):
@@ -1091,7 +1123,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _Error(self, op, other, Error, **txt_cause):
         '''(INTERNAL) Format an B{C{Error}} for C{{self} B{op} B{other}}.
         '''
-        return Error(_SPACE_(self.as_iscalar, op, other), **txt_cause)
+        # self.as_iscalar causes RecursionError for ._fprs2 errors
+        s = _Psum(self._ps, nonfinites=True, name=self.name)
+        return Error(_SPACE_(s.as_iscalar, op, other), **txt_cause)
 
     def _ErrorX(self, X, op, other, *mod):
         '''(INTERNAL) Format the caught exception C{X}.
@@ -1105,25 +1139,27 @@ 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)
-            _xs   = _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), _xs, up=up)
+            ps[:] =  self._ps_acc(list(ps), fs, up=up)
         return self
 
     def _facc_args(self, xs, **up):
         '''(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.
@@ -1141,7 +1177,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         def _Pow4(p):
             r = 0
-            if _isFsumTuple(p):
+            if _isFsum_2Tuple(p):
                 s, r = p._fprs2
                 if r:
                     m = Fsum._pow
@@ -1158,7 +1194,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         _Pow, p, s, r = _Pow4(power)
         if p:  # and xs:
             op   =  which.__name__
-            _FsT = _Fsum_Fsum2Tuple_types
+            _FsT = _Fsum_2Tuple_types
             _pow =  self._pow_2_3
 
             def _P(X):
@@ -1172,24 +1208,32 @@ 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
 
     def _facc_scalar(self, xs, **up):
-        '''(INTERNAL) Accumulate all C{xs}, known to be scalar.
+        '''(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):
-        '''(INTERNAL) Accumulate all positional C{xs}, known to be scalar.
+        '''(INTERNAL) Accumulate all positional C{xs}, each C{scalar}.
         '''
-        if xs:
-            _ = self._ps_acc(self._ps, xs, **up)
-        return self
+        return self._facc_scalar(xs, **up)
+
+    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}.
+        '''
+        _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
@@ -1208,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}).
 
@@ -1219,7 +1263,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @raise ValueError: Invalid or I{non-finite} B{C{xs}} value.
         '''
-        if _isFsumTuple(xs):
+        if _isFsum_2Tuple(xs):
             self._facc_scalar(xs._ps)
         elif isscalar(xs):    # for backward compatibility # PYCHOK no cover
             x = _2float(x=xs, **self._isfine)
@@ -1231,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 _isFsumTuple(other):
-            if self._ps:
-                self._facc_scalar(other._ps, **up)
-            else:
-                self._fset(other, op=op, **up)
+        if _isFsum_2Tuple(other):
+            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
@@ -1276,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 _isFsumTuple(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):
@@ -1346,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 = 0  # 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 = 0  # 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}.'''
@@ -1406,31 +1438,35 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         q = self._ftruediv(other, op, **raiser_RESIDUAL)  # == self
         return self._fset(q.floor)  # floor(q)
 
-    def fma(self, other1, other2, raiser=False):  # in .fmath.fma
+    def fma(self, other1, other2, **nonfinites):  # in .fmath.fma
         '''Fused-multiply-add C{self *= B{other1}; self += B{other2}}.
 
            @arg other1: Multiplier (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @arg other2: Addend (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
-           @kwarg raiser: If C{True}, throw an exception, otherwise pass
-                          the I{non-finite} result (C{bool}).
-
-           @note: Uses C{math.fma} in Python 3.13+, provided C{self},
-                  B{C{other1}} and B{C{other2}} are all C{scalar}.
+           @kwarg nonfinites: Use C{B{nonfinites}=True} or C{False}, to
+                              override L{nonfinites<Fsum.nonfinites>} and
+                              L{nonfiniterrors} default (C{bool}).
         '''
-        f, r = self._fprs2
-        if r == 0 and isscalar(other1, both=True) \
-                  and isscalar(other2, both=True):
-            try:
-                f = _fma(f, other1, other2)
-            except (OverflowError, TypeError, ValueError) as X:  # from math.fma
-                op = self.fma.__name__  # INF, NAN, NINF
-                f =  self._mul_reduce(op, f, other1)
-                f = _sum(self._ps_other(op, f, other2))
-                if raiser:
-                    f = self._nonfiniteX(X, op, f)
-        else:
-            f  = self._f2mul(self.fma, other1, raiser=raiser)
-            f += other2
+        op  = self.fma.__name__
+        _fs = self._ps_other
+        try:
+            s, r = self._fprs2
+            if r:
+                f  =  self._f2mul(self.fma, other1, **nonfinites)
+                f +=  other2
+            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(s, other1)  # INF, NAN, NINF
+            f += sum(_fs(op, other2))
+            f  = self._nonfiniteX(X, op, f, **nonfinites)
         return self._fset(f)
 
     fmul = __imul__
@@ -1438,11 +1474,11 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _fmul(self, other, op):
         '''(INTERNAL) Apply C{B{self} *= B{other}}.
         '''
-        if _isFsumTuple(other):
+        if _isFsum_2Tuple(other):
             if len(self._ps) != 1:
                 f = self._mul_Fsum(other, op)
             elif len(other._ps) != 1:  # and len(self._ps) == 1
-                f = self._ps_mul(op, *other._ps)
+                f = self._ps_mul(op, *other._ps) if other._ps else _0_0
             elif self._f2product:  # len(other._ps) == 1
                 f = self._mul_scalar(other._ps[0], op)
             else:  # len(other._ps) == len(self._ps) == 1
@@ -1457,39 +1493,41 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''DEPRECATED on 2024.09.13, use method L{f2mul_<Fsum.f2mul_>}.'''
         return self._fset(self.f2mul_(*others, **raiser))
 
-    def f2mul_(self, *others, **raiser):  # in .fmath.f2mul
+    def f2mul_(self, *others, **nonfinites):  # in .fmath.f2mul
         '''Return C{B{self} * B{other} * B{other} ...} for all B{C{others}} using cascaded,
            accurate multiplication like with L{f2product<Fsum.f2product>} set to C{True}.
 
            @arg others: Multipliers (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}), all
                         positional.
-           @kwarg raiser: Keyword argument C{B{raiser}=False}, if C{True}, throw an exception,
-                          otherwise pass the I{non-finite} result (C{bool}).
+           @kwarg nonfinites: Use C{B{nonfinites}=True} or C{False}, to override both
+                              L{nonfinites<Fsum.nonfinites>} and the L{nonfiniterrors}
+                              default (C{bool}).
 
            @return: The cascaded I{TwoProduct} (L{Fsum} or C{float}).
 
            @see: U{Equations 2.3<https://www.TUHH.De/ti3/paper/rump/OzOgRuOi06.pdf>}
         '''
-        return self._f2mul(self.f2mul_, *others, **raiser)
+        return self._f2mul(self.f2mul_, *others, **nonfinites)
 
-    def _f2mul(self, where, *others, **raiser):
+    def _f2mul(self, where, *others, **nonfinites_raiser):
         '''(INTERNAL) See methods C{fma} and C{f2mul_}.
         '''
-        f = self._copy_2(where)
-        if others:
+        f  = self._copy_2(where)
+        ps = f._ps
+        if ps and others:
             op = where.__name__
-            ps = f._ps
-            if ps:
-                try:
-                    for p in self._ps_other(op, *others):
+            try:
+                for other in others:  # to pinpoint errors
+                    for p in self._ps_other(op, other):
                         pfs   = _2products(p, _2split3s(ps))
                         ps[:] =  f._ps_acc([], pfs, up=False)
-                    f._update()
-                except (OverflowError, TypeError, ValueError) as X:
-                    r = self._mul_reduce(op, _sum(ps), *others)  # INF, NAN, NINF
-                    if _xkwds_get1(raiser, raiser=False):
-                        r = self._nonfiniteX(X, op, r)
-                    f._fset(r)
+                f._update()
+            except TypeError as X:
+                raise self._ErrorX(X, op, other)
+            except (OverflowError, ValueError) as X:
+                r = self._mul_reduce(sum(ps), other)  # INF, NAN, NINF
+                r = self._nonfiniteX(X, op, r, **nonfinites_raiser)
+                f._fset(r)
         return f
 
     def fover(self, over, **raiser_RESIDUAL):
@@ -1520,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)
@@ -1531,8 +1569,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
     def f2product(self, *two):
         '''Get and set accurate I{TwoProduct} multiplication for this
-           L{Fsum}, I{overriding the global setting} from function
-           L{f2product<fsums.f2product>}.
+           L{Fsum}, overriding the L{f2product} default.
 
            @arg two: If omitted, leave the override unchanged, if C{True},
                      turn I{TwoProduct} on, if C{False} off, if C{None}e
@@ -1564,7 +1601,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         s, _ = self._fprs2
         return s  # ._fprs2.fsum
 
-    @_fprs.setter_  # PYCHOK setter_underscore!
+    @_fprs.setter_  # PYCHOK setter_UNDERscore!
     def _fprs(self, s):
         '''(INTERNAL) Replace the C{_fprs} value.
         '''
@@ -1576,30 +1613,37 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            running sum and residual (L{Fsum2Tuple}).
         '''
         ps = self._ps
+        n  = len(ps)
         try:
-            n = len(ps) - 2
-            if n > 0:  # len(ps) > 2
+            if n > 2:
                 s = _psum(ps, **self._isfine)
-                n =  len(ps) - 2
-                if n > 0:
+                if not _isfinite(s):
+                    ps[:] = s,  # collapse ps
+                    return Fsum2Tuple(s, _NONFINITEr)
+                n = len(ps)
+#               Fsum._ps_max = max(Fsum._ps_max, n)
+                if n > 2:
                     r = self._ps_1sum(s)
                     return Fsum2Tuple(*_s_r(s, r))
-            if n == 0:  # len(ps) == 2
+            if n > 1:  # len(ps) == 2
                 s, r  = _s_r(*_2sum(*ps, **self._isfine))
                 ps[:] = (r, s) if r else (s,)
             elif ps:  # len(ps) == 1
-                s, r = ps[0], INT0
+                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
-            s =  self._nonfiniteX(X, op, _sum(self._ps))
-            r = _0_0
+            op = _fset_op_  # INF, NAN, NINF
+            ps[:] = sum(ps),  # collapse ps
+            s =  self._nonfiniteX(X, op, ps[0])
+            r = _NONFINITEr
         # assert self._ps is ps
         return Fsum2Tuple(s, r)
 
-    @_fprs2.setter_  # PYCHOK setter_underscore!
+    @_fprs2.setter_  # PYCHOK setter_UNDERscore!
     def _fprs2(self, s_r):
         '''(INTERNAL) Replace the C{_fprs2} value.
         '''
@@ -1616,15 +1660,18 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.fadd} for further details.
         '''
-        return self._fset(xs[0], op=_fset_op_) if len(xs) == 1 else \
-               self._fset(_0_0)._facc_args(xs)
+        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}.
         '''
         if other is self:
             pass  # from ._fmul, ._ftruediv and ._pow_0_1
-        elif _isFsumTuple(other):
+        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
@@ -1647,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.
 
@@ -1664,13 +1706,13 @@ 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}}.
         '''
-        if _isFsumTuple(other):
+        if _isFsum_2Tuple(other):
             if other is self:  # or other._fprs2 == self._fprs2:
                 self._fset(_0_0, n=len(self) * 2)
             elif other._ps:
@@ -1680,11 +1722,11 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         return self
 
     def fsum(self, xs=()):
-        '''Add an iterable's items, summate and return the
-           current precision running sum.
+        '''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}).
 
@@ -1695,11 +1737,11 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         return self._facc(xs)._fprs
 
     def fsum_(self, *xs):
-        '''Add any positional items, summate and return the
-           current precision running sum.
+        '''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}).
 
@@ -1723,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):
@@ -1740,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]) 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
@@ -1768,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},
@@ -1779,33 +1821,36 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         return self._fsum2(xs, self._facc_args)
 
-    def _fsum2(self, xs, _facc, **origin):
+    def _fsum2(self, xs, _facc, **facc_kwds):
         '''(INTERNAL) Helper for L{Fsum.fsum2_} and L{Fsum.fsum2f_}.
         '''
         p, q = self._fprs2
         if xs:
-            s, r = _facc(xs, **origin)._fprs2
+            s, r = _facc(xs, **facc_kwds)._fprs2
             if _isfinite(s):  # _fsum(_1primed((s, -p, r, -q))
                 d, r = _2sum(s - p, r - q, _isfine=_isOK)
                 r, _ = _s_r(d, r)
-            return s, (r if _isfinite(r) else _0_0)
+            return s, (r if _isfinite(r) else _NONFINITEr)
         else:
             return p, _0_0
 
     def fsumf_(self, *xs):
-        '''Like method L{Fsum.fsum_} iff I{all} C{B{xs}} are I{known to be scalar}.
+        '''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_scalar(xs)._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}} are I{known to be scalar}.
+        '''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_scalar(xs)._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}} are I{known to be scalar}.
+        '''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_scalar, origin=1)
+        return self._fsum2(xs, self._facc_scalarf, which=self.fsum2f_)  # origin=1?
 
 #   ftruediv = __itruediv__   # for naming consistency?
 
@@ -1813,7 +1858,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''(INTERNAL) Apply C{B{self} /= B{other}}.
         '''
         n = _1_0
-        if _isFsumTuple(other):
+        if _isFsum_2Tuple(other):
             if other is self or self == other:
                 return self._fset(n, n=len(self))
             d, r = other._fprs2
@@ -1846,9 +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{integer} sum if this instance C{is_integer},
-                    otherwise return 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}}.
@@ -1878,7 +1923,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Function L{isfinite<pygeodesy.isfinite>}.
         '''
-        return _isfinite(_sum(self._ps))  # _sum(self)
+        return _isfinite(sum(self._ps))  # == sum(self)
 
     def is_integer(self):
         '''Is this instance' running sum C{integer}? (C{bool}).
@@ -1895,7 +1940,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                     an C{fma} implementation as C{math.fma} or C{None}, a previous
                     C{PyGeodesy} implementation.
         '''
-        return (_fma.__module__ is fabs.__module__ or None) if _2split3s is _passarg else False
+        return (_2split3s is _passarg) or (False if _2n_d is None else None)
 
     def is_math_fsum(self):
         '''Are the summation functions L{fsum}, L{fsum_}, L{fsumf_}, L{fsum1},
@@ -1907,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 _isFsumTuple(other)
+        # 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)
@@ -1967,11 +2016,20 @@ 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
-           C{ValueError} exceptions, I{overriding the global setting} from
-           function L{nonfiniterrors<fsums.nonfiniterrors>}.
+           C{ValueError} exceptions, overriding the L{nonfiniterrors} default.
 
            @arg OK: If omitted, leave the override unchanged, if C{True},
                     I{non-finites} are C{OK}, if C{False} throw exceptions
@@ -1981,14 +2039,16 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Function L{nonfiniterrors<fsums.nonfiniterrors>}.
 
-           @note: Use C{f.nonfinites() or not nonfiniterrors()} to determine
-                  whether L{Fsum} C{f} handles I{non-finites}.
+           @note: Use property L{nonfinitesOK<Fsum.nonfinitesOK>} to determine
+                  whether I{non-finites} are C{OK} for this L{Fsum} and by the
+                  L{nonfiniterrors} default.
         '''
         _ks = Fsum._nonfinites_isfine_kwds
         if OK:  # delattrof(self, _isfine=None)
             k = _xkwds_pop(self.__dict__, _isfine=None)
             if OK[0] is not None:
                 self._isfine = _ks[bool(OK[0])]
+            self._update()
         else:  # getattrof(self, _isfine=None)
             k = _xkwds_get(self.__dict__, _isfine=None)
         # dict(map(reversed, _ks.items())).get(k, None)
@@ -1999,10 +2059,21 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     _nonfinites_isfine_kwds = {True:  dict(_isfine=_isOK),
                                False: dict(_isfine=_isfinite)}
 
-    def _nonfiniteX(self, X, op, f):
+    @property_RO
+    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 _isOK_or_finite(INF, **self._isfine)
+
+    def _nonfiniteX(self, X, op, f, nonfinites=None, raiser=None):
         '''(INTERNAL) Handle a I{non-finite} exception.
         '''
-        if not _isOK_or_finite(f, **self._isfine):
+        if nonfinites is None:
+            nonfinites = _isOK_or_finite(f, **self._isfine) if raiser is None else (not raiser)
+        if not nonfinites:
             raise self._ErrorX(X, op, f)
         return f
 
@@ -2063,10 +2134,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _pow(self, other, unused, op, **raiser_RESIDUAL):
         '''Return C{B{self} ** B{other}}.
         '''
-        if _isFsumTuple(other):
+        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)
@@ -2084,7 +2155,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
         if mod:  # b, x, mod all C{int}, unless C{mod} is C{None}
             m = mod[0]
-            # assert _isFsumTuple(b)
+            # assert _isFsum_2Tuple(b)
 
             def _s(s, r):
                 R = self._raiser(r, s, **raiser_RESIDUAL)
@@ -2093,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)
@@ -2101,14 +2172,15 @@ 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)
 
     def _pow_Fsum(self, other, op, **raiser_RESIDUAL):
-        '''(INTERNAL) Return C{B{self} **= B{other}} for C{_isFsumTuple(other)}.
+        '''(INTERNAL) Return C{B{self} **= B{other}} for C{_isFsum_2Tuple(other)}.
         '''
-        # assert _isFsumTuple(other)
+        # assert _isFsum_2Tuple(other)
         x, r = other._fprs2
         f = self._pow_scalar(x, other, op, **raiser_RESIDUAL)
         if f and r:
@@ -2202,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):
@@ -2219,19 +2290,21 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             if len(ps) < len(fs):
                 ps, fs = fs, ps
             if self._f2product:
-                ps   = _2split3s(ps)
-                _fps = _2products
+                fs, p = _2split3s(fs), fs
+                if len(ps) > 1 and fs is not p:
+                    fs = tuple(fs)  # several ps
+                _pfs = _2products
             else:
-                def _fps(f, ps):
-                    return (f * p for p in ps)
+                def _pfs(p, fs):
+                    return (p * f for f in fs)
 
-            for f in fs:
-                for p in _fps(f, ps):
-                    yield p if _isfine(p) else self._finite(p, op)
+            for p in ps:
+                for f in _pfs(p, fs):
+                    yield f if _isfine(f) else _nfError(f)
 
-        F  =  self._Fsum_as(name=op)  # assert F._ps is not self._ps
-        _s = _psfs(self._ps, factors, **self._isfine)
-        return F._facc_scalar(_s, up=False)
+        fs = _psfs(self._ps, factors, **self._isfine)
+        f  = _Psum(self._ps_acc([], fs, up=False), name=op)
+        return f
 
     @property_RO
     def _ps_neg(self):
@@ -2240,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 _isFsumTuple(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.
@@ -2345,7 +2417,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def root(self, root, **raiser_RESIDUAL):
         '''Return C{B{self}**(1 / B{root})} as L{Fsum}.
 
-           @arg root: The order (C{scalar}, L{Fsum} or L{Fsum2Tuple}), non-zero.
+           @arg root: Non-zero order (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @kwarg raiser_RESIDUAL: Use C{B{raiser}=False} to ignore any
                          L{ResidualError}s (C{bool}) or C{B{RESIDUAL}=scalar}
                          to override the current L{RESIDUAL<Fsum.RESIDUAL>}.
@@ -2362,7 +2434,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         return f._fpow(x, f.name, **raiser_RESIDUAL)  # == pow(f, x)
 
     def _scalar(self, other, op, **txt):
-        '''(INTERNAL) Return scalar C{other}.
+        '''(INTERNAL) Return scalar C{other} or throw a C{TypeError}.
         '''
         if isscalar(other):
             return other
@@ -2371,12 +2443,12 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def signOf(self, res=True):
         '''Determine the sign of this instance.
 
-           @kwarg res: If C{True}, consider, otherwise ignore
-                       the residual (C{bool}).
+           @kwarg res: If C{True}, consider the residual,
+                       otherwise ignore the latter (C{bool}).
 
            @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)
 
@@ -2404,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):
@@ -2427,7 +2499,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
 _ROs = _allPropertiesOf_n(3, Fsum, Property_RO)  # PYCHOK see Fsum._update
 
-if _NONFINITES:  # PYCHOK no cover
+if _NONFINITES == _std_:  # PYCHOK no cover
     _ = nonfiniterrors(False)
 
 
@@ -2574,7 +2646,7 @@ class Fsum2Tuple(_NamedTuple):  # in .fstats
         '''
         return Fmt.PAREN(fstr(self, fmt=fmt, strepr=str, force=False, **prec_sep))
 
-_Fsum_Fsum2Tuple_types = Fsum, Fsum2Tuple  # PYCHOK lines
+_Fsum_2Tuple_types = Fsum, Fsum2Tuple  # PYCHOK lines
 
 
 class ResidualError(_ValueError):
@@ -2603,7 +2675,7 @@ except ImportError:
     def _fsum(xs):
         '''(INTERNAL) Precision summation, Python 2.5-.
         '''
-        F = Fsum(name=_fsum.name, nonfinites=True)
+        F = Fsum(name=_fsum.name, f2product=False, nonfinites=True)
         return float(F._facc(xs, up=False))
 
 
@@ -2613,8 +2685,7 @@ def fsum(xs, nonfinites=None, **floats):
        @arg xs: Iterable of items to add (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
        @kwarg nonfinites: Use C{B{nonfinites}=True} if I{non-finites} are C{OK}, if
                           C{False} I{non-finites} raise an Overflow-/ValueError or if
-                          C{None}, apply C{B{nonfinites}=not }L{nonfiniterrors()}
-                          (C{bool} or C{None}).
+                          C{None}, L{nonfiniterrors} applies (C{bool} or C{None}).
        @kwarg floats: DEPRECATED keyword argument C{B{floats}=False} (C{bool}), use
                       keyword argument C{B{nonfinites}=False} instead.
 
@@ -2640,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):
@@ -2651,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):
@@ -2673,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):
@@ -2685,45 +2756,50 @@ def fsum1f_(*xs):
     return _xsum(fsum1f_, xs, nonfinites=True, primed=1) if xs else _0_0
 
 
-def _xs(xs, _x, i_x):
-    '''(INTERNAL) Yield all C{xs} as C{scalar}.
-    '''
-    for i, x in enumerate(xs):
-        i_x[:] = i, x
-        if _isFsumTuple(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 _xsError(X, xs, i, x, *n):  # in _2floats, ._fstats
-    '''(INTERNAL) Error for C{xs} or C{x}, item C{xs[i]}.
-    '''
-    return ((_xError(X, n[0], xs) if n else
-             _xError(X, xs=xs))   if x is xs else
-             _xError(X, Fmt.INDEX(xs=i), x))
+def _X_ps(X):  # default C{_X} handler
+    return X._ps  # lambda X: X._ps
 
 
-def _xsum(which, xs, nonfinites=None, origin=0, primed=0, **floats):
-    '''(INTERNAL) Precision summation of C{xs} with conditions.
+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 nonfinites is None:
-            nonfinites =  not nonfiniterrors()
-        elif floats:
-            nonfinites = _xkwds_get1(floats, floats=nonfinites)
-        fs = _xs(xs, (_passarg if nonfinites else _2finite), i_x)
-        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:
-        i, x = i_x
-        i +=  origin - (1 if primed else 0)
-        t  = _xsError(X, xs, i, x)
-        t  = _COMMASPACE_(unstr(which), t)
+        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.
 del _allPropertiesOf_n, deprecated_method, deprecated_property_RO, \
      Property, Property_RO, property_RO, _ALL_LAZY, _F2PRODUCT, \