pygeodesy 24.4.4__py2.py3-none-any.whl → 24.4.18__py2.py3-none-any.whl

pygeodesy/elliptic.py

@@ -97,7 +97,7 @@ from math import asinh, atan, atan2, ceil, cosh, fabs, floor, \
                  radians, sin, sqrt, tanh
 
 __all__ = _ALL_LAZY.elliptic
-__version__ = '24.03.22'
+__version__ = '24.04.14'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
@@ -112,7 +112,7 @@ class _Cs(object):
         self.__dict__ = kwds
 
 
-class _D(list):
+class _Dsum(list):
     '''(INTERNAL) Deferred C{Fsum}.
     '''
     def __call__(self, s):
@@ -405,7 +405,7 @@ class Elliptic(_Named):
         # For kp2 close to zero use asin(r / cE) or J. P. Boyd,
         # Applied Math. and Computation 218, 7005-7013 (2012)
         # <https://DOI.org/10.1016/j.amc.2011.12.021>
-        _Phi2, self._iteration = Phi.fsum2_, 0  # aggregate
+        _Phi2, self._iteration = Phi.fsum2f_, 0  # aggregate
         for i in range(1, _TRIPS):  # GEOGRAPHICLIB_PANIC
             sn, cn, dn = self._sncndn3(phi)
             if dn:
@@ -896,7 +896,7 @@ class Elliptic3Tuple(_NamedTuple):
     _Units_ = ( Scalar, Scalar, Scalar)
 
 
-class _L(list):
+class _List(list):
     '''(INTERNAL) Helper for C{_RD}, C{_RF3} and C{_RJ}.
     '''
     _a0   = None
@@ -938,7 +938,7 @@ class _L(list):
                 r = fdot(s[:3], s[1], s[2], s[0])  # sqrt(x) * sqrt(y) + ...
             except ValueError:  # Fsum(NAN) exception
                 r = _sum(s[i] * s[(i + 1) % 3] for i in range(3))
-            L[:] = [(r + _) * _0_25 for _ in L]
+            L[:] = ((r + _) * _0_25 for _ in L)
             a    =  (r + a) * _0_25
             if y:  # yield only if used
                 yield a, m, r, s  # L[2] is next z
@@ -951,9 +951,10 @@ class _L(list):
         '''Rescale C{x}, C{y}, ...
         '''
         # assert am
-        a0 = self._a0
+        a0  =  self._a0
+        _am = _1_0 / am
         for x in xs:
-            yield (a0 - x) / am
+            yield (a0 - x) * _am
 
 
 def _ab2(inst, x, y):
@@ -961,16 +962,15 @@ def _ab2(inst, x, y):
     '''
     a, b = sqrt(x), sqrt(y)
     if b > a:
-        a, b = b, a
-    yield a, b  # initial x0, y0
+        b, a = a, b
     for i in range(_TRIPS):
+        yield a, b  # xi, yi
         d =  fabs(a - b)
         t = _TolRG0 * a
         if d <= t:  # 3-4 trips
             _iterations(inst, i)
             break
         a, b = ((a + b) * _0_5), sqrt(a * b)
-        yield a, b  # xn, yn
     else:  # PYCHOK no cover
         raise _convergenceError(d, t)
 
@@ -1023,15 +1023,16 @@ def _Horner(S, e1, E2, E3, E4, E5, *over):
     #    + 3*E5/26 - E2**3/16 + 3*E3**2/40 + 3*E2*E4/20
     #    + 45*E2**2*E3/272 - 9*(E3*E4+E2*E5)/68)
     # converted to Horner-like form ...
-    F  = Fsum
     e  = e1 * 4084080
     S *= e
-    S += F(E2 * -540540,                               471240).fmul(E5)
-    S += F(E2 *  612612,                E3 * -540540, -556920).fmul(E4)
-    S += F(E2 * -706860, E22 *  675675, E3 *  306306,  680680).fmul(E3)
-    S += F(E2 *  417690, E22 * -255255,               -875160).fmul(E2)
+    S += Fsum(E2 * -540540,                               471240).fmul(E5)
+    S += Fsum(E2 *  612612,                E3 * -540540, -556920).fmul(E4)
+    S += Fsum(E2 * -706860, E22 *  675675, E3 *  306306,  680680).fmul(E3)
+    S += Fsum(E2 *  417690, E22 * -255255,               -875160).fmul(E2)
     S += 4084080
-    return S.fdiv((over[0] * e) if over else e)  # Fsum
+    if over:
+        e *= over[0]
+    return S.fdiv(e)  # Fsum
 
 
 def _iterations(inst, i):
@@ -1069,8 +1070,8 @@ def _rC(unused, x, y):
 def _RD(inst, x, y, z, *over):
     '''(INTERNAL) Carlson, eqs 2.28 - 2.34.
     '''
-    L = _L(x, y, z)
-    S = _D()
+    L = _List(x, y, z)
+    S = _Dsum()
     for a, m, r, s in L.amrs4(inst, True, _TolRF):
         if s:
             S += _over(_3_0, (r + z) * s[2] * m)
@@ -1097,7 +1098,7 @@ def _rF2(inst, x, y):  # 2-arg version, z=0
 def _RF3(inst, x, y, z):  # 3-arg version
     '''(INTERNAL) Carlson, eqs 2.2 - 2.7.
     '''
-    L = _L(x, y, z)
+    L = _List(x, y, z)
     for a, m, _, _ in L.amrs4(inst, False, _TolRF):
         pass
     x, y = L.rescale(a * m, x, y)
@@ -1120,14 +1121,14 @@ def _rG2(inst, x, y, PI_=PI_4):  # 2-args
     '''(INTERNAL) Carlson, eqs 2.36 - 2.39.
     '''
     m = -1  # neg!
-    S = _D()
-    # assert not S
+    S = None
     for a, b in _ab2(inst, x, y):  # PYCHOK yield
-        if S:
+        if S is None:  # initial
+            S  = _Dsum()
+            S += (a + b)**2 * _0_5
+        else:
             S += (a - b)**2 *  m
             m *=  2
-        else:  # initial
-            S += (a + b)**2 * _0_5
     return S(PI_).fover(a + b)
 
 
@@ -1148,9 +1149,9 @@ def _RJ(inst, x, y, z, p, *over):
     def _xyzp(x, y, z, p):
         return (x + p) * (y + p) * (z + p)
 
-    L = _L(x, y, z, p)
+    L = _List(x, y, z, p)
     n =  neg(_xyzp(x, y, z, -p))
-    S = _D()
+    S = _Dsum()
     for a, m, _, s in L.amrs4(inst, True, _TolRD):
         if s:
             d = _xyzp(*s)

pygeodesy/errors.py

@@ -11,9 +11,9 @@ chaining}, use command line option C{python -X dev} I{OR} set env variable
 C{PYTHONDEVMODE=1} or to any non-empty string I{OR} set env variable
 C{PYGEODESY_EXCEPTION_CHAINING=std} or to any non-empty string.
 '''
-# from pygeodesy.basics import isint, isodd, itemsorted, _xinstanceof, _zip  # _MODS
+# from pygeodesy.basics import isint, isodd, issubclassof, itemsorted, _xinstanceof, _zip  # _MODS
 # from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase, LatLonEllipsoidalBase  # _MODS
-# from pygeodesy import errors  # _MODS.getattr
+# from pygeodesy import errors  # _MODS, _MODS.getattr
 from pygeodesy.interns import MISSING, NN, _a_, _an_, _and_, _clip_, _COLON_, \
                              _COLONSPACE_, _COMMASPACE_, _datum_, _ellipsoidal_, \
                              _incompatible_, _invalid_, _len_, _not_, _or_, _SPACE_, \
@@ -25,7 +25,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv, _PYTHON_X_D
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '24.03.24'
+__version__ = '24.04.18'
 
 _box_        = 'box'
 _limiterrors =  True  # in .formy
@@ -425,7 +425,7 @@ def _error_init(Error, inst, args, fmt_name_value='%s (%r)', txt=NN,
 def _error_under(inst):
     '''(INTERNAL) Remove leading underscore from instance' class name.
     '''
-    n = inst.__class__.__name__
+    n = inst.__class__.__name__  # _tailof?
     if n.startswith(_UNDER_):
         inst.__class__.__name__ = n.lstrip(_UNDER_)
     return inst
@@ -479,8 +479,15 @@ def isError(exc):
                 C{False} if B{C{exc}} is a standard Python error
                 of C{None} if neither.
     '''
-    return True  if isinstance(exc, _XErrors)   else (
-           False if isinstance(exc,  Exception) else None)
+    def _X(exc):
+        X = type(exc)
+        m = X.__module__
+        return _MODS.basics.issubclassof(X, *_XErrors) or \
+               ((m is __name__ or m == __name__) and
+               _tailof(X.__name__).startswith(_UNDER_))
+
+    return True   if isinstance(exc, _XErrors)   else (
+          _X(exc) if isinstance(exc,  Exception) else None)
 
 
 def _IsnotError(*nouns, **name_value_Error_cause):  # name=value [, Error=TypeError, cause=None]
@@ -665,31 +672,23 @@ def _xError2(exc):  # in .constants, .fsums, .lazily, .vector2d
 
        @arg exc: The exception instance (usually, C{Exception}).
     '''
-    m =  __name__  # 'pygeodesy.errors'
-    X =  type(exc)
-    n =  NN(_UNDER_, _tailof(X.__name__))
-    E = _MODS.getattr(m, n, X)  # == _X2Error.get(X, X)
-    if E is X and not isError(exc):
-        E = _NotImplementedError
-        t =  repr(exc)
-    else:
-        t =  str(exc)
-    return E, t
+    x = isError(exc)
+    if x:
+        E =  type(exc)
+    elif x is None:
+        E = _AssertionError
+    else:  # get _Error from Error
+        n =  NN(_UNDER_, _tailof(type(exc).__name__))
+        E = _MODS.getattr(__name__, n, _NotImplementedError)
+        x =  E is not _NotImplementedError
+    return E, (str(exc) if x else repr(exc))
 
 
-_XErrors = _TypeError, _ValueError
+_XErrors = (_AssertionError, _AttributeError,  # some isError's
+            _TypeError, _ValueError, _ZeroDivisionError)
 # map certain C{Exception} classes to the C{_Error}
-# _X2Error = {AssertionError:      _AssertionError,
-#             AttributeError:      _AttributeError,
-#             ImportError:         _ImportError,
-#             IndexError:          _IndexError,
-#             KeyError:            _KeyError,
-#             NameError:           _NameError,
-#             NotImplementedError: _NotImplementedError,
-#             OverflowError:       _OverflowError,
-#             TypeError:           _TypeError,
-#             ValueError:          _ValueError,
-#             ZeroDivisionError:   _ZeroDivisionError}
+# _X2Error = {AssertionError:    _AssertionError, ...
+#             ZeroDivisionError: _ZeroDivisionError}
 
 try:
     _ = {}.__or__  # {} | {}  # Python 3.9+

pygeodesy/etm.py

@@ -92,7 +92,7 @@ from pygeodesy.utm import _cmlon, _LLEB, _parseUTM5, _toBand, _toXtm8, \
 from math import asinh, atan2, degrees, radians, sinh, sqrt
 
 __all__ = _ALL_LAZY.etm
-__version__ = '24.03.22'
+__version__ = '24.04.07'
 
 _OVERFLOW = _1_EPS**2  # about 2e+31
 _TAYTOL   =  pow(EPS, 0.6)
@@ -606,8 +606,8 @@ class ExactTransverseMercator(_NamedBase):
             _zetaDwd2 = self._sigmaDwd2
 
         d2, r = tol2, self.raiser
-        _U_2  = Fsum(u).fsum2_
-        _V_2  = Fsum(v).fsum2_
+        _U_2  = Fsum(u).fsum2f_
+        _V_2  = Fsum(v).fsum2f_
         # min iterations 2, max 6 or 7, mean 3.9 or 4.0
         for i in range(1, _TRIPS):  # GEOGRAPHICLIB_PANIC
             sncndn6 =  self._sncndn6(u, v)

pygeodesy/fmath.py

@@ -13,8 +13,8 @@ from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
                                _copysign_0_0, _isfinite, _over, remainder
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
                              _xError, _xkwds_get, _xkwds_pop2
-from pygeodesy.fsums import _2float, Fsum, _fsum, fsum, fsum1_, _pow_op_, \
-                            _1primed,  Fmt, unstr
+from pygeodesy.fsums import _2float, Fsum, _fsum, fsum, fsum1_, _1primed, \
+                             Fmt, unstr
 from pygeodesy.interns import MISSING, _few_, _h_, _invokation_, _negative_, \
                              _not_scalar_, _SPACE_, _too_
 from pygeodesy.lazily import _ALL_LAZY, _sys_version_info2
@@ -25,13 +25,21 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '24.04.04'
+__version__ = '24.04.17'
 
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ... sqrt(2) - 1
 _h_lt_b_ = 'abs(h) < abs(b)'
 
 
+def _Fsum__init__(inst, raiser=MISSING, **name_RESIDUAL):
+    '''(INTERNAL) Init an C{Fsum} instance.
+    '''
+    Fsum.__init__(inst, **name_RESIDUAL)  # PYCHOK self
+    inst._fset_ps(_0_0)
+    return {} if raiser is MISSING else dict(raiser=raiser)
+
+
 class Fdot(Fsum):
     '''Precision dot product.
     '''
@@ -41,8 +49,8 @@ class Fdot(Fsum):
 
            @arg a: Iterable, list, tuple, etc. (C{scalar}s).
            @arg b: Other values (C{scalar}s), all positional.
-           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and
-                       C{B{RESIDUAL}=None}, see L{Fsum.__init__}.
+           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and C{B{RESIDUAL}=None},
+                       see L{Fsum<Fsum.__init__>}.
 
            @raise OverflowError: Partial C{2sum} overflow.
 
@@ -64,8 +72,8 @@ class Fhorner(Fsum):
            @arg x: Polynomial argument (C{scalar} or C{Fsum} instance).
            @arg cs: Polynomial coeffients (C{scalar} or C{Fsum}
                     instances), all positional.
-           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and
-                       C{B{RESIDUAL}=None}, see L{Fsum.__init__}.
+           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and C{B{RESIDUAL}=None},
+                       see L{Fsum<Fsum.__init__>}.
 
            @raise OverflowError: Partial C{2sum} overflow.
 
@@ -92,32 +100,30 @@ class Fhorner(Fsum):
             else:  # x == 0
                 self._fadd(cs[0], op)
         else:
-            self._fset(_0_0)
+            self._fset_ps(_0_0)
 
 
 class Fhypot(Fsum):
     '''Precision summation and hypotenuse, default C{power=2}.
     '''
-    def __init__(self, *xs, **power_name_RESIDUAL):
-        '''New L{Fhypot} hypotenuse of (the I{power} of) several components.
+    def __init__(self, *xs, **root_name_RESIDUAL_raiser):
+        '''New L{Fhypot} hypotenuse of (the I{root} of) several components.
 
-           @arg xs: One or more components (each a C{scalar} or an C{Fsum}
-                    instance).
-           @kwarg power_name_RESIDUAL: Optional, C{scalar} exponent and
-                        root order C{B{power}=2}, a C{B{name}=NN} and
-                        C{B{RESIDUAL}=None}, see L{Fsum.__init__}.
+           @arg xs: One or more components (each a C{scalar} or an C{Fsum} instance).
+           @kwarg root_name_RESIDUAL_raiser: Optional, exponent and C{B{root}=2} order,
+                       C{B{name}=NN}, C{B{RESIDUAL}=None} and C{B{raiser}=True}, see
+                       class L{Fsum<Fsum.__init__>} and method L{root<Fsum.root>}.
         '''
+        r = None  # _xkwds_pop2 error
         try:
-            p, kwds = _xkwds_pop2(power_name_RESIDUAL, power=2)
-            Fsum.__init__(self, **kwds)
+            r, kwds = _xkwds_pop2(root_name_RESIDUAL_raiser, root=2)
+            r, kwds = _xkwds_pop2(kwds, power=r)  # for backward compatibility
+            raiser  = _Fsum__init__(self, **kwds)
             if xs:
-                r = _1_0 / p
-                self._facc_power(p, xs, Fhypot)
-                self._fpow(r, _pow_op_)
-            else:
-                self._fset(_0_0)
-        except Exception as x:
-            raise self._ErrorXs(x, xs, power=p)
+                self._facc_power(r, xs, Fhypot, **raiser)
+            self._fset(self.root(r, **raiser))
+        except Exception as X:
+            raise self._ErrorXs(X, xs, root=r)
 
 
 class Fpolynomial(Fsum):
@@ -128,10 +134,10 @@ class Fpolynomial(Fsum):
            M{sum(cs[i] * x**i for i=0..len(cs)-1)}.
 
            @arg x: Polynomial argument (C{scalar} or L{Fsum}).
-           @arg cs: Polynomial coeffients (each a C{scalar} or
-                    an L{Fsum} instance), all positional.
-           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and
-                       C{B{RESIDUAL}=None}, see L{Fsum.__init__}.
+           @arg cs: Polynomial coeffients (each a C{scalar} or an L{Fsum} instance),
+                    all positional.
+           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and C{B{RESIDUAL}=None},
+                       see L{Fsum<Fsum.__init__>}.
 
            @raise OverflowError: Partial C{2sum} overflow.
 
@@ -147,75 +153,68 @@ class Fpolynomial(Fsum):
         if n > 0:
             self.fadd(_1map_mul(cs[1:], _powers(x, n)))
         elif n < 0:
-            self._fset(_0_0)
+            self._fset_ps(_0_0)
 
 
 class Fpowers(Fsum):
     '''Precision summation of powers, optimized for C{power=2, 3 and 4}.
     '''
-    def __init__(self, power, *xs, **name_RESIDUAL):
+    def __init__(self, power, *xs, **name_RESIDUAL_raiser):
         '''New L{Fpowers} sum of (the I{power} of) several values.
 
            @arg power: The exponent (C{scalar} or L{Fsum}).
-           @arg xs: One or more values (each a C{scalar} or an
-                    C{Fsum} instance).
-           @kwarg name_RESIDUAL: Optional C{B{name}=NN} and
-                       C{B{RESIDUAL}=None}, see L{Fsum.__init__}.
+           @arg xs: One or more values (each a C{scalar} or an C{Fsum} instance).
+           @kwarg name_RESIDUAL_raiser: Optional C{B{name}=NN}, C{B{RESIDUAL}=None} and
+                       C{B{raiser}=True}, see L{Fsum<Fsum.__init__>} and L{fpow<Fsum.fpow>}.
         '''
         try:
-            Fsum.__init__(self, **name_RESIDUAL)
+            raiser = _Fsum__init__(self, **name_RESIDUAL_raiser)
             if xs:
-                self._facc_power(power, xs, Fpowers)  # x**0 == 1
-            else:
-                self._fset(_0_0)
-        except Exception as x:
-            raise self._ErrorXs(x, xs, power=power)
+                self._facc_power(power, xs, Fpowers, **raiser)  # x**0 == 1
+        except Exception as X:
+            raise self._ErrorXs(X, xs, power=power)
 
 
-class Fn_rt(Fsum):
-    '''N-th root of a precision summation.
+class Froot(Fsum):
+    '''The root of a precision summation.
     '''
-    def __init__(self, root, *xs, **name_RESIDUAL):
-        '''New L{Fn_rt} root of a precision sum.
+    def __init__(self, root, *xs, **name_RESIDUAL_raiser):
+        '''New L{Froot} root of a precision sum.
 
-           @arg root: The order (C{scalar} or C{Fsum}),
-                      non-zero.
-           @arg xs: Values to summate (each a C{scalar} or
-                    an C{Fsum} instance).
-           @kwarg name_RESIDUAL: See L{Fsum.__init__}.
+           @arg root: The order (C{scalar} or C{Fsum}), non-zero.
+           @arg xs: Values to summate (each a C{scalar} or an C{Fsum} instance).
+           @kwarg name_RESIDUAL_raiser: Optional C{B{name}=NN}, C{B{RESIDUAL}=None} and
+                       C{B{raiser}=True}, see L{Fsum<Fsum.__init__>} and L{fpow<Fsum.fpow>}.
         '''
         try:
-            Fsum.__init__(self, **name_RESIDUAL)
+            raiser = _Fsum__init__(self, **name_RESIDUAL_raiser)
             if xs:
-                r = _1_0 / root
                 self. fadd(xs)
-                self._fpow(r, _pow_op_)  # self **= r
-            else:
-                self._fset(_0_0)
-        except Exception as x:
-            raise self._ErrorXs(x, xs, root=root)
+            self._fset(self.root(root, **raiser))
+        except Exception as X:
+            raise self._ErrorXs(X, xs, root=root)
 
 
-class Fcbrt(Fn_rt):
+class Fcbrt(Froot):
     '''Cubic root of a precision summation.
     '''
-    def __init__(self, *xs, **name_RESIDUAL):
+    def __init__(self, *xs, **name_RESIDUAL_raiser):
         '''New L{Fcbrt} cubic root of a precision sum.
 
-           @see: Class L{Fn_rt} for further details.
+           @see: Class L{Froot} for further details.
         '''
-        Fn_rt.__init__(self, _3_0, *xs, **name_RESIDUAL)
+        Froot.__init__(self, _3_0, *xs, **name_RESIDUAL_raiser)
 
 
-class Fsqrt(Fn_rt):
+class Fsqrt(Froot):
     '''Square root of a precision summation.
     '''
-    def __init__(self, *xs, **name_RESIDUAL):
+    def __init__(self, *xs, **name_RESIDUAL_raiser):
         '''New L{Fsqrt} square root of a precision sum.
 
-           @see: Class L{Fn_rt} for further details.
+           @see: Class L{Froot} for further details.
         '''
-        Fn_rt.__init__(self, _2_0, *xs, **name_RESIDUAL)
+        Froot.__init__(self, _2_0, *xs, **name_RESIDUAL_raiser)
 
 
 def bqrt(x):
@@ -818,7 +817,7 @@ def _map_mul(a, b, where):
     n = len(b)
     if len(a) != n:  # PYCHOK no cover
         raise LenError(where, a=len(a), b=n)
-    return map(_operator.mul, a, b) if n > 3 else _1map_mul(a, b)
+    return _1map_mul(a, b) if n < 4 else map(_operator.mul, a, b)
 
 
 def _1map_mul(a, b):

pygeodesy/frechet.py

@@ -89,7 +89,7 @@ import pygeodesy.formy as _formy
 from pygeodesy.interns import NN, _DOT_, _n_, _units_
 # from pygeodesy.iters import points2 as _points2  # from .points
 from pygeodesy.lazily import _ALL_LAZY, _FOR_DOCS
-from pygeodesy.named import _Named, _NamedTuple, notOverloaded, _Pass
+from pygeodesy.named import _Named, _NamedTuple, _Pass
 # from pygeodesy.namedTuples import PhiLam2Tuple  # from .points
 from pygeodesy.points import _distanceTo, _fractional,  isscalar, \
                               PhiLam2Tuple, points2 as _points2, radians
@@ -102,7 +102,7 @@ from collections import defaultdict as _defaultdict
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.frechet
-__version__ = '24.03.24'
+__version__ = '24.04.07'
 
 
 def _fraction(fraction, n):
@@ -248,7 +248,7 @@ class Frechet(_Named):
 
     def _func(self, *args, **kwds):  # PYCHOK no cover
         '''(INTERNAL) I{Must be overloaded}.'''
-        notOverloaded(self, *args, **kwds)
+        self._notOverloaded(*args, **kwds)
 
     @property_RO
     def kwds(self):
@@ -325,7 +325,7 @@ class FrechetDegrees(Frechet):
 
     def distance(self, point1, point2, *args, **kwds):  # PYCHOK no cover
         '''I{Must be overloaded}.'''
-        notOverloaded(self, point1, point2, *args, **kwds)
+        self._notOverloaded(point1, point2, *args, **kwds)
 
 
 class FrechetRadians(Frechet):
@@ -339,7 +339,7 @@ class FrechetRadians(Frechet):
 
     def distance(self, point1, point2, *args, **kwds):  # PYCHOK no cover
         '''I{Must be overloaded}.'''
-        notOverloaded(self, point1, point2, *args, **kwds)
+        self._notOverloaded(point1, point2, *args, **kwds)
 
     def point(self, point):
         '''Return B{C{point}} as L{PhiLam2Tuple} to maintain
@@ -373,7 +373,7 @@ class _FrechetMeterRadians(Frechet):
 
     def _func_(self, *args, **kwds):  # PYCHOK no cover
         '''(INTERNAL) I{Must be overloaded}.'''
-        notOverloaded(self, *args, **kwds)
+        self._notOverloaded(*args, **kwds)
 
 
 class FrechetCosineAndoyerLambert(_FrechetMeterRadians):

pygeodesy/fstats.py

@@ -15,15 +15,14 @@ from pygeodesy.fmath import hypot2,  sqrt
 from pygeodesy.fsums import _2float, Fsum,  Fmt
 from pygeodesy.interns import NN, _iadd_op_, _invalid_, _other_, _SPACE_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
-from pygeodesy.named import _Named, _NotImplemented, notOverloaded, \
-                             property_RO
+from pygeodesy.named import _Named, _NotImplemented, property_RO
 # from pygeodesy.props import property_RO  # from .named
 # from pygeodesy.streprs import Fmt  # from .fsums
 
 # from math import sqrt  # from .fmath
 
 __all__ = _ALL_LAZY.fstats
-__version__ = '23.09.22'
+__version__ = '24.04.07'
 
 _Floats =  Fsum, float
 _Scalar = _Floats + (int,)  # XXX basics._Ints is ABCMeta in Python 2
@@ -114,7 +113,7 @@ class _FstatsBase(_FstatsNamed):
 
     def fadd(self, xs, sample=False):  # PYCHOK no cover
         '''I{Must be overloaded}.'''
-        notOverloaded(self, xs, sample=sample)
+        self._notOverloaded(xs, sample=sample)
 
     def fadd_(self, *xs, **sample):
         '''Accumulate and return the current count.