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

pygeodesy/fsums.py

@@ -47,7 +47,8 @@ from pygeodesy.constants import INF, INT0, MANT_DIG, NEG0, NINF, _0_0, \
                                Float, Int
 from pygeodesy.errors import _AssertionError, _OverflowError, _TypeError, \
                              _ValueError, _xError, _xError2, _xkwds_get, \
-                             _xkwds, _xkwds_get1, _xkwds_not, _xkwds_pop
+                             _xkwds, _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 +65,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.09.29'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -86,12 +87,12 @@ _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
+_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'
 
 
@@ -102,15 +103,15 @@ def _2finite(x):  # in .fstats
             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
@@ -122,7 +123,7 @@ def _2floats(xs, origin=0, _X=_X_ps, _x=float, _isfine=_isfinite):
     '''
     try:
         i, x =  origin, xs
-        _FsT = _Fsum_Fsum2Tuple_types
+        _FsT = _Fsum_2Tuple_types
         for x in _xiterable(xs):
             if isinstance(x, _FsT):
                 for p in _X(x._Fsum):
@@ -135,32 +136,28 @@ def _2floats(xs, origin=0, _X=_X_ps, _x=float, _isfine=_isfinite):
         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
+            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_:
+        # back 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
@@ -179,51 +176,68 @@ except ImportError:  # Python 3.12-
                 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.
         if isnan(r):
-            def _is(x):
+            def _x(x):
                 return not isnan(x)
         else:
-            _is = _isfinite
-        if all(map(_is, a_b_c)):
+            _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 Fsum._f2mul
+        # 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:
+            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)))
-            else:
+            elif a:
                 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
+
+    _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,15 +260,15 @@ 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), up=False)
 
 
 def _2halfeven(s, r, p):
@@ -275,14 +289,14 @@ 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
 
@@ -294,12 +308,21 @@ def _isOK_or_finite(x, _isfine=_isfinite):
     return _isfine(x)
 
 
+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)
+
+
 def _nfError(x, *args):
     '''(INTERNAL) Throw a C{not-finite} exception.
     '''
     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)
 
@@ -360,7 +383,7 @@ def _psum(ps, **_isfine):  # PYCHOK used!
         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
 
@@ -385,7 +408,7 @@ def _2scalar2(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}.
     '''
-    if _isFsumTuple(other):
+    if _isFsum_2Tuple(other):
         s, r = other._fint2
         if r:
             s, r = other._fprs2
@@ -447,9 +470,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 +500,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>},
@@ -499,7 +522,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     _isfine    = {}  # == _isfinite
     _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):
@@ -1043,7 +1066,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)
@@ -1091,7 +1114,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}.
@@ -1113,9 +1138,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         if xs:
             kwds  = _xkwds(self._isfine, **origin_X_x)
-            _xs   = _2floats(xs, **kwds)  # PYCHOK yield
+            fs    = _2floats(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):
@@ -1141,7 +1166,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 +1183,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):
@@ -1178,18 +1203,27 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         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)
         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, **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)
 
 #   def _facc_up(self, up=True):
 #       '''(INTERNAL) Update the C{partials}, by removing
@@ -1219,7 +1253,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)
@@ -1241,7 +1275,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _fadd(self, other, op, **up):  # in .fmath.Fhorner
         '''(INTERNAL) Apply C{B{self} += B{other}}.
         '''
-        if _isFsumTuple(other):
+        if _isFsum_2Tuple(other):
             if self._ps:
                 self._facc_scalar(other._ps, **up)
             else:
@@ -1283,7 +1317,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''
         if _xiterablen(cs):
             H = self._Fsum_as(name__=self._fhorner)
-            if _isFsumTuple(x):
+            if _isFsum_2Tuple(x):
                 _mul = H._mul_Fsum
             else:
                 _mul = H._mul_scalar
@@ -1352,8 +1386,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             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))
+            r = _NONFINITEr  # INF, NAN, NINF
+            i =  self._fintX(X, sum(self._ps))
         return i, r  # Fsum2Tuple?
 
     @_fint2.setter_  # PYCHOK setter_UNDERscore!
@@ -1364,8 +1398,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             i =  int(s)
             r = (s - i) or INT0
         except (OverflowError, ValueError) as X:
-            r = 0  # INF, NAN, NINF
-            i = self._fintX(X, float(s))
+            r = _NONFINITEr  # INF, NAN, NINF
+            i =  self._fintX(X, float(s))
         return i, r  # like _fint2.getter
 
     def _fintX(self, X, i):  # PYCHOK X
@@ -1406,31 +1440,32 @@ 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
+            else:
+                fs = _2split3s(_fs(op, other1))
+                fs = _2products(s, fs, *_fs(op, other2))
+                f  = _Psum(self._ps_acc([], fs, up=False), name=op)
+        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)
         return self._fset(f)
 
     fmul = __imul__
@@ -1438,11 +1473,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 +1492,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(op, 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):
@@ -1531,8 +1568,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 +1600,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 +1612,36 @@ 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
                 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 = sum.__name__  # 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 +1658,15 @@ 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 = self._Fsum_as(*xs)
+        return self._fset(f, up=False, 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):
             self._ps[:] = other._ps
             self._n     = n or other._n
             if up:  # use or zap the C{Property_RO} values
@@ -1670,7 +1712,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     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,8 +1722,8 @@ 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).
@@ -1695,8 +1737,8 @@ 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.
@@ -1742,7 +1784,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             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 (
+        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):
@@ -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, origin=1, which=self.fsumf_)._fprs
 
     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, origin=1, which=self.Fsumf_)._copy_2(self.Fsumf_)
 
     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, origin=1, which=self.fsum2f_)
 
 #   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,8 @@ 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}, 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 +1922,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 +1939,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},
@@ -1929,7 +1973,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _mul_Fsum(self, other, op=_mul_op_):  # in .fmath.Fhorner
         '''(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!
         else:
@@ -1970,8 +2014,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     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 +2024,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 +2044,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 nf
+
+    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,7 +2119,7 @@ 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)
@@ -2084,7 +2140,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)
@@ -2106,9 +2162,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             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:
@@ -2203,7 +2259,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         if n:
             self._n += n
 #           if _fi:  # collapse ps if non-finite
-#               x = _sum(ps)
+#               x = sum(ps)
 #               if not _isfinite(x):
 #                   ps[:] = x,
             # Fsum._ps_max = max(Fsum._ps_max, len(ps))
@@ -2219,19 +2275,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 self._finite(f, op)
 
-        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):
@@ -2244,7 +2302,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''(INTERNAL) Yield all C{other}s as C{scalar}.
         '''
         for other in others:
-            if _isFsumTuple(other):
+            if _isFsum_2Tuple(other):
                 for p in other._ps:
                     yield p
             else:
@@ -2345,7 +2403,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 +2420,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,8 +2429,8 @@ 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).
         '''
@@ -2427,7 +2485,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 +2632,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 +2661,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 +2671,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.
 
@@ -2685,43 +2742,34 @@ def fsum1f_(*xs):
     return _xsum(fsum1f_, xs, nonfinites=True, primed=1) if xs else _0_0
 
 
-def _xs(xs, _x, i_x):
+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 _isFsumTuple(x):
+        if _isFsum_2Tuple(x):
             for p in map(_x, x._ps):
                 yield p
         else:
             yield _x(x)
 
 
-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 _xsum(which, xs, nonfinites=None, origin=0, primed=0, **floats):
     '''(INTERNAL) Precision summation of C{xs} with conditions.
     '''
     i_x = [0, xs]
     try:
-        if nonfinites is None:
-            nonfinites =  not nonfiniterrors()
-        elif floats:
+        if floats:  # for backward compatibility
             nonfinites = _xkwds_get1(floats, floats=nonfinites)
-        fs = _xs(xs, (_passarg if nonfinites else _2finite), i_x)
+        elif nonfinites is None:
+            nonfinites =  not nonfiniterrors()
+        fs = _xs(xs, i_x, nonfinites)
         return _fsum(_1primed(fs) if primed else fs)
     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)
-        raise _xError(X, t, txt=None)
+        origin -= 1 if primed else 0
+        i_x    += [origin, which]
+        raise _ixError(X, xs, *i_x)
 
 
 # delete all decorators, etc.