pygeodesy 25.1.9__py2.py3-none-any.whl → 25.4.25__py2.py3-none-any.whl

pygeodesy/fsums.py

@@ -2,13 +2,13 @@
 # -*- coding: utf-8 -*-
 
 u'''Class L{Fsum} for precision floating point summation similar to
-Python's C{math.fsum} enhanced with I{running} summation and as an
-option, accurate I{TwoProduct} multiplication.
+Python's C{math.fsum}, but enhanced with I{precision running} summation
+plus optionally, accurate I{TwoProduct} multiplication.
 
-Accurate multiplication is based on the C{math.fma} function for
-Python 3.13 and newer or one of two equivalent C{fma} implementations
-for Python 3.12 and older.  To enable accurate multiplication, set
-env variable C{PYGEODESY_FSUM_F2PRODUCT} to C{"std"} or any non-empty
+Accurate multiplication is based on the C{math.fma} function from
+Python 3.13 and newer or an equivalent C{fma} implementation for
+Python 3.12 and older.  To enable accurate multiplication, set env
+variable C{PYGEODESY_FSUM_F2PRODUCT} to C{"std"} or any non-empty
 string or invoke function C{pygeodesy.f2product(True)} or set.  With
 C{"std"} the C{fma} implemention follows the C{math.fma} function,
 otherwise the C{PyGeodesy 24.09.09} release.
@@ -39,8 +39,8 @@ results may differ from Python's C{math.fsum} results.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import isbool, iscomplex, isint, isscalar, \
-                            _signOf, itemsorted, signOf, _xiterable
+from pygeodesy.basics import _gcd, isbool, iscomplex, isint, isscalar, \
+                             _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
@@ -48,12 +48,12 @@ from pygeodesy.errors import _AssertionError, _OverflowError, _TypeError, \
                              _ValueError, _xError, _xError2, _xkwds, \
                              _xkwds_get, _xkwds_get1, _xkwds_not, \
                              _xkwds_pop, _xsError
-from pygeodesy.internals import _enquote, _getPYGEODESY, _MODS, _passarg
-from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DOT_, _from_, \
+from pygeodesy.internals import _enquote, _envPYGEODESY, _passarg, typename
+from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DMAIN_, _DOT_, _from_, \
                              _not_finite_, _SPACE_, _std_, _UNDER_
-# from pygeodesy.lazily import _ALL_LAZY  # from .named
+# from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
 from pygeodesy.named import _name__, _name2__, _Named, _NamedTuple, \
-                            _NotImplemented,  _ALL_LAZY
+                            _NotImplemented,  _ALL_LAZY, _MODS
 from pygeodesy.props import _allPropertiesOf_n, deprecated_method, \
                              deprecated_property_RO, Property, \
                              Property_RO, property_RO
@@ -64,30 +64,30 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '24.12.02'
+__version__ = '25.04.14'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
+  _DSLASH_   as _floordiv_op_,
   _EQUAL_    as _fset_op_,
   _RANGLE_   as _gt_op_,
   _LANGLE_   as _lt_op_,
   _PERCENT_  as _mod_op_,
   _STAR_     as _mul_op_,
   _NOTEQUAL_ as _ne_op_,
+  _DSTAR_    as _pow_op_,
   _DASH_     as _sub_op_,  # in .auxilats.auxAngle
   _SLASH_    as _truediv_op_
 )
-_floordiv_op_ = _truediv_op_ * 2  # _DSLASH_
 _divmod_op_   = _floordiv_op_ + _mod_op_
-_F2PRODUCT    = _getPYGEODESY('FSUM_F2PRODUCT')
+_F2PRODUCT    = _envPYGEODESY('FSUM_F2PRODUCT')
 _iadd_op_     = _add_op_ + _fset_op_  # in .auxilats.auxAngle, .fstats
 _integer_     = 'integer'
 _isub_op_     = _sub_op_ + _fset_op_  # in .auxilats.auxAngle
 _NONFINITEr   = _0_0  # NOT INT0!
-_NONFINITES   = _getPYGEODESY('FSUM_NONFINITES')
+_NONFINITES   = _envPYGEODESY('FSUM_NONFINITES')
 _non_zero_    = 'non-zero'
-_pow_op_      = _mul_op_ * 2  # _DSTAR_
-_RESIDUAL_0_0 = _getPYGEODESY('FSUM_RESIDUAL', _0_0)
+_RESIDUAL_0_0 = _envPYGEODESY('FSUM_RESIDUAL', _0_0)
 _significant_ = 'significant'
 _threshold_   = 'threshold'
 
@@ -96,7 +96,7 @@ def _2finite(x, _isfine=_isfinite):  # in .fstats
     '''(INTERNAL) return C{float(x)} if finite.
     '''
     return (float(x) if _isfine(x)  # and isscalar(x)
-            else _nfError(x))
+                   else _nfError(x))
 
 
 def _2float(index=None, _isfine=_isfinite, **name_x):  # in .fmath, .fstats
@@ -132,27 +132,25 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
 
     if _F2PRODUCT and _F2PRODUCT != _std_:
         # backward to PyGeodesy 24.09.09, with _fmaX
+        from pygeodesy.basics import _integer_ratio2
 
         def _fma(*a_b_c):  # PYCHOK no cover
             # mimick C{math.fma} from Python 3.13+,
             # the same accuracy, but ~14x slower
-            (na, da), (nb, db), (nc, dc) = map(_2n_d, a_b_c)
-            n  = na * nb * dc
-            n += da * db * nc
-            d  = da * db * dc
+            (n, d), (nb, db), (nc, dc) = map(_integer_ratio2, a_b_c)
+            # n, d = (n * nb * dc + d * db * nc), (d * db * dc)
+            d *= db
+            n *= nb * dc
+            n += nc * d
+            d *= dc
             try:
-                n, d = _n_d2(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):  # 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:
+        _integer_ratio2 = None  # redef, in Fsum.is_math_fma
 
         def _fma(a, b, c):  # PYCHOK redef
             # mimick C{math.fma} from Python 3.13+,
@@ -161,17 +159,15 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
             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):  # PYCHOK no cover
-        # handle non-finite as Python 3.13+ C-function U{math_fma_impl<https://
-        # GitHub.com/python/cpython/blob/main/Modules/mathmodule.c#L2305>}:
-        #  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.
+        # handle non-finite fma result as Python 3.13+ C-function U{math_fma_impl
+        # <https://GitHub.com/python/cpython/blob/main/Modules/mathmodule.c#L2305>}:
+        # raise a ValueError for a NAN result from non-NAN C{a_b_c}s otherwise an
+        # OverflowError for a non-finite, non-NAN result from all finite C{a_b_c}s.
         if isnan(r):
             def _x(x):
                 return not isnan(x)
-        else:  # non-NAN non-finite
+        else:  # non-finite, non-NAN
             _x = _isfinite
         if all(map(_x, a_b_c)):
             raise _nfError(r, unstr(_fma, *a_b_c))
@@ -179,10 +175,8 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
 
     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/mathmodule.c} under
-        # #ifndef UNRELIABLE_FMA ... #else ... #endif
+        # TwoProduct U{Algorithm 3.3<https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}, also
+        # in Python 3.13+ C{Modules/mathmodule.c} under #ifndef UNRELIABLE_FMA ... #else ...
         _, a, b = _2split3(x)
         for y, c, d in y3s:
             y *= x
@@ -278,29 +272,20 @@ def _isOK(unused):
 def _isOK_or_finite(x, _isfine=_isfinite):
     '''(INTERNAL) Is C{x} finite or is I{non-finite} OK?
     '''
-    # assert _isfine in (_isOK, _isfinite)
+    # assert _isin(_isfine, _isOK, _isfinite)
     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 _n_d2(n, d):
+    '''(INTERNAL) Reduce C{n} and C{d} by C{gcd}.
+    '''
+    try:
+        c = _gcd(n, d)
+        if c > 1:
+            return (n // c), (d // c)
+    except TypeError:  # non-int float
+        pass
+    return n, d
 
 
 def _nfError(x, *args):
@@ -418,7 +403,7 @@ def _s_r2(s, r):
 def _strcomplex(s, *args):
     '''(INTERNAL) C{Complex} 2- or 3-arg C{pow} error as C{str}.
     '''
-    c = _strcomplex.__name__[4:]
+    c =  typename(_strcomplex)[4:]
     n = _sub_op_(len(args), _arg_)
     t =  unstr(pow, *args)
     return _SPACE_(c, s, _from_, n, t)
@@ -427,8 +412,8 @@ def _strcomplex(s, *args):
 def _stresidual(prefix, residual, R=0, **mod_ratio):
     '''(INTERNAL) Residual error txt C{str}.
     '''
-    p = _stresidual.__name__[3:]
-    t =  Fmt.PARENSPACED(p, Fmt(residual))
+    p = typename(_stresidual)[3:]
+    t = Fmt.PARENSPACED(p, Fmt(residual))
     for n, v in itemsorted(mod_ratio):
         p =  Fmt.PARENSPACED(n, Fmt(v))
         t = _COMMASPACE_(t, p)
@@ -548,7 +533,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''Return C{abs(self)} as an L{Fsum}.
         '''
         s = self.signOf()  # == self._cmp_0(0)
-        return (-self) if s < 0 else self._copy_2(self.__abs__)
+        return (-self) if s < 0 else self._copyd(self.__abs__)
 
     def __add__(self, other):
         '''Return C{B{self} + B{other}} as an L{Fsum}.
@@ -559,7 +544,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Methods L{Fsum.fadd_} and L{Fsum.fadd}.
         '''
-        f = self._copy_2(self.__add__)
+        f = self._copyd(self.__add__)
         return f._fadd(other)
 
     def __bool__(self):  # PYCHOK Python 3+
@@ -592,7 +577,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @raise TypeError: Incompatible B{C{other}} C{type}.
         '''
-        s = self._cmp_0(other, self.cmp.__name__)
+        s = self._cmp_0(other, typename(self.cmp))
         return _signOf(s, 0)
 
     def __divmod__(self, other, **raiser_RESIDUAL):
@@ -610,7 +595,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.fdiv}.
         '''
-        f = self._copy_2(self.__divmod__)
+        f = self._copyd(self.__divmod__)
         return f._fdivmod2(other, _divmod_op_, **raiser_RESIDUAL)
 
     def __eq__(self, other):
@@ -644,7 +629,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Methods L{Fsum.__ifloordiv__}.
         '''
-        f = self._copy_2(self.__floordiv__)
+        f = self._copyd(self.__floordiv__)
         return f._floordiv(other, _floordiv_op_)
 
     def __ge__(self, other):
@@ -859,7 +844,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__imod__}.
         '''
-        f = self._copy_2(self.__mod__)
+        f = self._copyd(self.__mod__)
         return f._fdivmod2(other, _mod_op_).mod
 
     def __mul__(self, other):
@@ -867,7 +852,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__imul__}.
         '''
-        f = self._copy_2(self.__mul__)
+        f = self._copyd(self.__mul__)
         return f._fmul(other, _mul_op_)
 
     def __ne__(self, other):
@@ -878,20 +863,20 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def __neg__(self):
         '''Return C{copy(B{self})}, I{negated}.
         '''
-        f = self._copy_2(self.__neg__)
+        f = self._copyd(self.__neg__)
         return f._fset(self._neg)
 
     def __pos__(self):
         '''Return this instance I{as-is}, like C{float.__pos__()}.
         '''
-        return self if _pos_self else self._copy_2(self.__pos__)
+        return self if _pos_self else self._copyd(self.__pos__)
 
     def __pow__(self, other, *mod):  # PYCHOK 2 vs 3 args
         '''Return C{B{self}**B{other}} as an L{Fsum}.
 
            @see: Method L{Fsum.__ipow__}.
         '''
-        f = self._copy_2(self.__pow__)
+        f = self._copyd(self.__pow__)
         return f._fpow(other, _pow_op_, *mod)
 
     def __radd__(self, other):
@@ -899,7 +884,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__iadd__}.
         '''
-        f = self._copy_2r(other, self.__radd__)
+        f = self._rcopyd(other, self.__radd__)
         return f._fadd(self)
 
     def __rdivmod__(self, other):
@@ -908,7 +893,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__divmod__}.
         '''
-        f = self._copy_2r(other, self.__rdivmod__)
+        f = self._rcopyd(other, self.__rdivmod__)
         return f._fdivmod2(self, _divmod_op_)
 
 #       turned off, called by _deepcopy and _copy
@@ -917,7 +902,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 #           <https://docs.Python.org/3/library/pickle.html#object.__reduce__>}
 #       '''
 #       dict_ = self._Fsum_as().__dict__  # no __setstate__
-#       return (self.__class__, self.partials, dict_)
+#       return (type(self), self.partials, dict_)
 
 #   def __repr__(self):
 #       '''Return the default C{repr(this)}.
@@ -929,7 +914,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__ifloordiv__}.
         '''
-        f = self._copy_2r(other, self.__rfloordiv__)
+        f = self._rcopyd(other, self.__rfloordiv__)
         return f._floordiv(self, _floordiv_op_)
 
     def __rmatmul__(self, other):  # PYCHOK no coveS
@@ -941,7 +926,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__imod__}.
         '''
-        f = self._copy_2r(other, self.__rmod__)
+        f = self._rcopyd(other, self.__rmod__)
         return f._fdivmod2(self, _mod_op_).mod
 
     def __rmul__(self, other):
@@ -949,7 +934,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__imul__}.
         '''
-        f = self._copy_2r(other, self.__rmul__)
+        f = self._rcopyd(other, self.__rmul__)
         return f._fmul(self, _mul_op_)
 
     def __round__(self, *ndigits):  # PYCHOK Python 3+
@@ -957,7 +942,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @arg ndigits: Optional number of digits (C{int}).
         '''
-        f = self._copy_2(self.__round__)
+        f = self._copyd(self.__round__)
         # <https://docs.Python.org/3.12/reference/datamodel.html?#object.__round__>
         return f._fset(round(float(self), *ndigits))  # can be C{int}
 
@@ -966,7 +951,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__ipow__}.
         '''
-        f = self._copy_2r(other, self.__rpow__)
+        f = self._rcopyd(other, self.__rpow__)
         return f._fpow(self, _pow_op_, *mod)
 
     def __rsub__(self, other):
@@ -974,7 +959,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__isub__}.
         '''
-        f = self._copy_2r(other, self.__rsub__)
+        f = self._rcopyd(other, self.__rsub__)
         return f._fsub(self, _sub_op_)
 
     def __rtruediv__(self, other, **raiser_RESIDUAL):
@@ -982,7 +967,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__itruediv__}.
         '''
-        f = self._copy_2r(other, self.__rtruediv__)
+        f = self._rcopyd(other, self.__rtruediv__)
         return f._ftruediv(self, _truediv_op_, **raiser_RESIDUAL)
 
     def __str__(self):
@@ -999,7 +984,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @see: Method L{Fsum.__isub__}.
         '''
-        f = self._copy_2(self.__sub__)
+        f = self._copyd(self.__sub__)
         return f._fsub(other, _sub_op_)
 
     def __truediv__(self, other, **raiser_RESIDUAL):
@@ -1104,10 +1089,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         # assert f._RESIDUAL is self._RESIDUAL
         return f
 
-    def _copy_2(self, which, name=NN):
+    def _copyd(self, which, name=NN):
         '''(INTERNAL) Copy for I{dyadic} operators.
         '''
-        n =  name or which.__name__  # _DUNDER_nameof
+        n =  name or typename(which)
         # NOT .classof due to .Fdot(a, *b) args, etc.
         f = _Named.copy(self, deep=False, name=n)
         f._ps = list(self._ps)  # separate list
@@ -1118,12 +1103,6 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         # assert f._RESIDUAL is self._RESIDUAL
         return f
 
-    def _copy_2r(self, other, which):
-        '''(INTERNAL) Copy for I{reverse-dyadic} operators.
-        '''
-        return other._copy_2(which) if _isFsum(other) else \
-                self._copy_2(which)._fset(other)
-
     divmod = __divmod__
 
     def _Error(self, op, other, Error, **txt_cause):
@@ -1209,7 +1188,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
         _Pow, p, s, r = _Pow4(power)
         if p:  # and xs:
-            op   =  which.__name__
+            op   =  typename(which)
             _FsT = _Fsum_2Tuple_types
             _pow =  self._pow_2_3
 
@@ -1246,8 +1225,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''(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,
+        fs = _xs(xs, **_x_isfine(self.nonfinitesOK, _Cdot=type(self),
                                **origin_which))  # PYCHOK yield
         return self._facc_scalar(fs, up=up)
 
@@ -1332,16 +1310,16 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
     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)}.
+           C{sum(c * B{x}**i for i, c in _e(cs))} where C{_e =
+           enumerate if B{incx} else _enumereverse}.
         '''
         # 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:
+            n = len(cs)
+            if n > 1 and _2finite(x, **self._isfine):
+                H  = self._Fsum_as(name__=self._fhorner)
+                _m = H._mul_Fsum if _isFsum_2Tuple(x) else \
+                     H._mul_scalar
                 for c in (reversed(cs) if incx else cs):
                     H._fset(_m(x, _mul_op_), up=False)
                     H._fadd(c, up=False)
@@ -1463,7 +1441,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                               override L{nonfinites<Fsum.nonfinites>} and
                               L{nonfiniterrors} default (C{bool}).
         '''
-        op  = self.fma.__name__
+        op  = typename(self.fma)
         _fs = self._ps_other
         try:
             s, r = self._fprs2
@@ -1528,7 +1506,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _f2mul(self, where, others, f2product=True, **nonfinites_raiser):
         '''(INTERNAL) See methods C{fma} and C{f2mul_}.
         '''
-        f = _Psum(self._ps, f2product=f2product, name=where.__name__)
+        n =  typename(where)
+        f = _Psum(self._ps, f2product=f2product, name=n)
         if others and f:
             if f.f2product():
                 def _pfs(f, ps):
@@ -1537,7 +1516,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                 def _pfs(f, ps):  # PYCHOK redef
                     return (f * p for p in ps)
 
-            op, ps = where.__name__, f._ps
+            op, ps = n, f._ps
             try:  # as if self.f2product(True)
                 for other in others:  # to pinpoint errors
                     for p in self._ps_other(op, other):
@@ -1776,7 +1755,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
            @return: Copy of this updated instance (L{Fsum}).
         '''
-        return self._facc_args(xs)._copy_2(self.Fsum_, **name)
+        return self._facc_args(xs)._copyd(self.Fsum_, **name)
 
     def Fsum2Tuple_(self, *xs, **name):
         '''Like method L{Fsum.fsum_} but returning a named L{Fsum2Tuple}.
@@ -1789,7 +1768,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
     @property_RO
     def _Fsum(self):  # like L{Fsum2Tuple._Fsum}, in .fstats
-        return self  # NOT @Property_RO, see .copy and ._copy_2
+        return self  # NOT @Property_RO, see .copy and ._copyd
 
     def _Fsum_as(self, *xs, **name_f2product_nonfinites_RESIDUAL):
         '''(INTERNAL) Return an C{Fsum} with this C{Fsum}'s C{.f2product},
@@ -1804,8 +1783,8 @@ 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], op=_fset_op_) if len(xs) == 1 else (
-               f._facc(xs, up=False) if xs else f)
+        return (f._facc(xs, up=False) if len(xs) > 1 else
+                f._fset(xs[0], op=_fset_op_)) if xs else f
 
     def fsum2(self, xs=(), **name):
         '''Add an iterable's items, summate and return the
@@ -1864,7 +1843,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         '''Like method L{Fsum.Fsum_} iff I{all} C{B{xs}}, each I{known to be}
            C{scalar}, an L{Fsum} or L{Fsum2Tuple}.
         '''
-        return self._facc_scalarf(xs, which=self.Fsumf_)._copy_2(self.Fsumf_)  # origin=1?
+        return self._facc_scalarf(xs, which=self.Fsumf_)._copyd(self.Fsumf_)  # origin=1?
 
     def fsum2f_(self, *xs):
         '''Like method L{Fsum.fsum2_} iff I{all} C{B{xs}}, each I{known to be}
@@ -1960,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 (_2split3s is _passarg) or (False if _2n_d is None else None)
+        return (_2split3s is _passarg) or (False if _integer_ratio2 is None else None)
 
     def is_math_fsum(self):
         '''Are the summation functions L{fsum}, L{fsum_}, L{fsumf_}, L{fsum1},
@@ -2148,7 +2127,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            @see: Methods L{Fsum.__ipow__}, L{Fsum.fint}, L{Fsum.is_integer}
                  and L{Fsum.root}.
         '''
-        f = self._copy_2(self.pow)
+        f = self._copyd(self.pow)
         return f._fpow(x, _pow_op_, *mod, **raiser_RESIDUAL)  # f = pow(f, x, *mod)
 
     def _pow(self, other, unused, op, **raiser_RESIDUAL):
@@ -2370,6 +2349,12 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                     return dict(ratio=q, R=t)
         return {}
 
+    def _rcopyd(self, other, which):
+        '''(INTERNAL) Copy for I{reverse-dyadic} operators.
+        '''
+        return other._copyd(which) if _isFsum(other) else \
+                self._copyd(which)._fset(other)
+
     rdiv = __rtruediv__
 
     @property_RO
@@ -2450,7 +2435,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
            @see: Method L{Fsum.pow}.
         '''
         x = self._1_Over(root, _truediv_op_, **raiser_RESIDUAL)
-        f = self._copy_2(self.root)
+        f = self._copyd(self.root)
         return f._fpow(x, f.name, **raiser_RESIDUAL)  # == pow(f, x)
 
     def _scalar(self, other, op, **txt):
@@ -2502,7 +2487,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _truediv(self, other, op, **raiser_RESIDUAL):
         '''(INTERNAL) Return C{B{self} / B{other}} as an L{Fsum}.
         '''
-        f = self._copy_2(self.__truediv__)
+        f = self._copyd(self.__truediv__)
         return f._ftruediv(other, op, **raiser_RESIDUAL)
 
     def _update(self, updated=True):  # see ._fset
@@ -2549,8 +2534,8 @@ class Fsum2Tuple(_NamedTuple):  # in .fstats
        @note: If the C{residual is INT0}, the C{fsum} is considered
               to be I{exact}, see method L{Fsum2Tuple.is_exact}.
     '''
-    _Names_ = ( Fsum.fsum.__name__, Fsum.residual.name)
-    _Units_ = (_Float_Int,         _Float_Int)
+    _Names_ = ( typename(Fsum.fsum), Fsum.residual.name)
+    _Units_ = (_Float_Int,          _Float_Int)
 
     def __abs__(self):  # in .fmath
         return self._Fsum.__abs__()
@@ -2642,7 +2627,7 @@ class Fsum2Tuple(_NamedTuple):  # in .fstats
 
     def _other_op(self, other, which):
         C, s = (tuple, self) if isinstance(other, tuple) else (Fsum, self._Fsum)
-        return getattr(C, which.__name__)(s, other)
+        return getattr(C, typename(which))(s, other)
 
     @property_RO
     def _ps(self):
@@ -2823,9 +2808,9 @@ def _xsum(which, xs, nonfinites=None, primed=0, **floats):  # origin=0
 # delete all decorators, etc.
 del _allPropertiesOf_n, deprecated_method, deprecated_property_RO, \
      Property, Property_RO, property_RO, _ALL_LAZY, _F2PRODUCT, \
-     MANT_DIG, _NONFINITES, _RESIDUAL_0_0, _getPYGEODESY, _std_
+     MANT_DIG, _NONFINITES, _RESIDUAL_0_0, _envPYGEODESY, _std_
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     # usage: python3 -m pygeodesy.fsums
 
@@ -2833,8 +2818,8 @@ if __name__ == '__main__':
         # copied from Hettinger, see L{Fsum} reference
         from pygeodesy import frandoms, printf
 
-        printf(_fsum.__name__, end=_COMMASPACE_)
-        printf(_psum.__name__, end=_COMMASPACE_)
+        printf(typename(_fsum), end=_COMMASPACE_)
+        printf(typename(_psum), end=_COMMASPACE_)
 
         F = Fsum()
         if F.is_math_fsum():

pygeodesy/gars.py

@@ -14,14 +14,14 @@ Transcoded from I{Charles Karney}'s C++ class U{GARS
       (GARS)<https://Earth-Info.NGA.mil/GandG/coordsys/grids/gars.html>}.
 '''
 
-# from pygeodesy.basics import isstr  # from .named
+from pygeodesy.basics import isstr, _splituple,  typename
 from pygeodesy.constants import _off90, _1_over, _0_5, \
                                 _1_0  # PYCHOK used!
 from pygeodesy.errors import _ValueError, _xkwds, _xStrError
-from pygeodesy.interns import NN, _0to9_, _AtoZnoIO_, _COMMA_, \
-                             _INV_, _SPACE_
+# from pygeodesy.internals import typename  # from .basics
+from pygeodesy.interns import NN, _0to9_, _AtoZnoIO_, _INV_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
-from pygeodesy.named import _name__,  Fmt, isstr, Property_RO
+from pygeodesy.named import _name__,  Fmt, Property_RO
 from pygeodesy.namedTuples import LatLon2Tuple, LatLonPrec3Tuple
 # from pygeodesy.props import Property_RO  # from .named
 # from pygeodesy.streprs import Fmt  # from .named
@@ -30,7 +30,7 @@ from pygeodesy.units import Int_, Lat, Lon, Precision_, Scalar_, Str
 from math import floor
 
 __all__ = _ALL_LAZY.gars
-__version__ = '24.08.13'
+__version__ = '25.04.14'
 
 _Digits  = _0to9_
 _LatLen  =    2
@@ -93,7 +93,7 @@ def _2garstr2(garef):
         return garstr, _2Precision(n - _MinLen)
 
     except (AttributeError, TypeError, ValueError) as x:
-        raise GARSError(Garef.__name__, garef, cause=x)
+        raise GARSError(typename(Garef), garef, cause=x)
 
 
 def _2Precision(precision):
@@ -136,7 +136,7 @@ class Garef(Str):
             if isinstance(lat_gll, Garef):
                 g, ll, p = str(lat_gll), lat_gll.latlon, lat_gll.precision
             elif isstr(lat_gll):
-                ll = lat_gll.replace(_COMMA_, _SPACE_).split()
+                ll = _splituple(lat_gll)
                 if len(ll) > 1:
                     g, ll, p = _encode3(ll[0], ll[1], precision)
                 else: