pygeodesy 24.8.24__py2.py3-none-any.whl → 24.9.9__py2.py3-none-any.whl

pygeodesy/internals.py

@@ -207,6 +207,13 @@ class _MODS_Base(object):
             l3.insert(0, pypy)
         return l3
 
+    @_Property_RO
+    def _Str_Bytes(self):
+        '''Get all C{str} and C{bytes} types.
+        '''
+        import pygeodesy.basics as m
+        return m._Strs + m._Bytes  # + (range, map)
+
     @_Property_RO
     def streprs(self):
         '''Get module C{pygeodesy.streprs}, I{once}.
@@ -254,6 +261,12 @@ def _enquote(strs, quote=_QUOTE2_, white=NN):  # in .basics, .solveBase
     return strs
 
 
+def _fper(p, q, per=100.0, prec=1):
+    '''Format a percentage C{B{p} * B{per} / B{q}} (C{str}).
+    '''
+    return '%.*f%%' % (prec, (float(p) * per / float(q)))
+
+
 def _headof(name):
     '''(INTERNAL) Get the head name of qualified C{name} or the C{name}.
     '''
@@ -292,6 +305,13 @@ def _isNix():  # in test/bases.py
     return _MODS.nix2[0]
 
 
+def _isPyChecker():
+    '''(INTERNAL) Is C{PyChecker} running? (C{bool}).
+    '''
+    # .../pychecker/checker.py --limit 0 --stdlib pygeodesy/<mod>/<name>.py
+    return _sys.argv[0].endswith('/pychecker/checker.py')
+
+
 def _isPyPy():  # in test/bases.py
     '''(INTERNAL) Is this C{PyPy}? (C{bool})
     '''
@@ -343,12 +363,30 @@ def machine():
     return _MODS.bits_machine2[1]
 
 
+def _Math_K_2():
+    '''(INTERNAL) Return the I{Karney} Math setting.
+    '''
+    return _MODS.karney._wrapped.Math_K_2
+
+
 def _name_version(pkg):
     '''(INTERNAL) Return C{pskg.__name__ + ' ' + .__version__}.
     '''
     return _SPACE_(pkg.__name__, pkg.__version__)
 
 
+def _name_binary(path):
+    '''(INTERNAL) Return C{(basename + ' ' + version)} of an executable.
+    '''
+    if path:
+        try:
+            _, r = _MODS.solveBase._popen2((path, '--version'))
+            return _SPACE_(_os_path.basename(path), r.split()[-1])
+        except (IndexError, IOError, OSError):
+            pass
+    return NN
+
+
 def _osversion2(sep=NN):  # in .lazily, test/bases.versions
     '''(INTERNAL) Get the O/S name and release as C{2-list} or C{str}.
     '''
@@ -463,15 +501,17 @@ def _secs2str(secs):  # in .geoids, ../test/bases.py
     return t
 
 
-def _sizeof(obj):
+def _sizeof(obj, deep=True):
     '''(INTERNAL) Recursively size an C{obj}ect.
 
-       @return: The C{obj} size in bytes (C{int}),
-                ignoring class attributes and
-                counting duplicates only once or
-                C{None}.
+       @kwarg deep: If C{True}, include the size of all
+                    C{.__dict__.values()} (C{bool}).
 
-       @note: With C{PyPy}, the size is always C{None}.
+       @return: The C{obj} size in bytes (C{int}), ignoring
+                class attributes and counting instances only
+                once or C{None}.
+
+       @note: With C{PyPy}, the returned size is always C{None}.
     '''
     try:
         _zB = _sys.getsizeof
@@ -491,9 +531,10 @@ def _sizeof(obj):
                 if isinstance(o, dict):
                     z += _zR(s, o.keys())
                     z += _zR(s, o.values())
-                elif _isiterablen(o):  # not map, ...
+                elif _isiterablen(o) and not \
+                      isinstance(o, _MODS._Str_Bytes):
                     z += _zR(s, o)
-                else:
+                elif deep:
                     try:  # size instance' attr values only
                         z += _zR(s, o.__dict__.values())
                     except AttributeError:  # None, int, etc.
@@ -611,7 +652,7 @@ def _versions(sep=_SPACE_):
 
 
 __all__ = tuple(map(_dunder_nameof, (machine, print_, printf)))
-__version__ = '24.08.24'
+__version__ = '24.09.04'
 
 if _dunder_ismain(__name__):  # PYCHOK no cover
 

pygeodesy/interns.py

@@ -200,6 +200,7 @@ _distant_     = _Prefix('distant')           # PYCHOK OK
 _doesn_t_exist_       = "doesn't exist"      # PYCHOK OK
 _DOT_            = Str_('.')                 # PYCHOK OK
 _dunder_name_         = '__name__'           # PYCHOK _DUNDER_(NN, _name_, NN)
+_duplicate_           = 'duplicate'          # PYCHOK OK
 _e_                   = 'e'                  # PYCHOK OK
 _E_                   = 'E'                  # PYCHOK OK
 _earth_               = 'earth'              # PYCHOK OK
@@ -347,7 +348,7 @@ _Python_     = _Python_('Python')            # PYCHOK singleton
 _python_              = 'python'             # PYCHOK OK
 _QUOTE1_              = "'"                  # PYCHOK OK
 _QUOTE2_              = '"'                  # PYCHOK OK
-# _QUOTE3_            = "'''"                # PYCHOK OK
+_QUOTE3_              = "'''"                # PYCHOK OK
 # _QUOTE6_            = '"""'                # PYCHOK OK
 _R_                   = 'R'                  # PYCHOK OK
 _radians_             = 'radians'            # PYCHOK OK
@@ -440,7 +441,7 @@ _LR_PAIRS  = {_LANGLE_:  _RANGLE_,
 
 __all__ = (_NN_,  # NOT MISSING!
             Str_.__name__)  # classes
-__version__ = '24.08.22'
+__version__ = '24.08.30'
 
 if __name__ == '__main__':
 

pygeodesy/karney.py

@@ -10,7 +10,9 @@ C{attribute} name.
 
 With env variable C{PYGEODESY_GEOGRAPHICLIB} left undefined or set to C{"2"}, modules L{geodesicw},
 L{geodesicx} and this module will use U{GeographicLib 2.0+<https://GeographicLib.SourceForge.io/C++/doc/>}
-and newer transcoding, otherwise C{1.52} or older.
+and newer transcoding, otherwise C{1.52} or older.  Set C{PYGEODESY_GEOGRAPHICLIB=2.4} to default to the
+C{Jacobi amplitude} instead of C{Bulirsch}' function in methods L{ExactTransverseMercator.forward
+<pygeodesy.ExactTransverseMercator.forward>} and L{reverse <pygeodesy.ExactTransverseMercator.reverse>}.
 
 Karney-based functionality
 ==========================
@@ -145,8 +147,8 @@ from pygeodesy.basics import _copysign, isint, neg, unsigned0, _xgeographiclib,
                              _zip,  _version_info
 from pygeodesy.constants import NAN, _isfinite as _math_isfinite, _0_0, \
                                _1_16th, _1_0, _2_0, _180_0, _N_180_0, _360_0
-from pygeodesy.errors import GeodesicError, _ValueError, _xkwds, _xkwds_get1
-from pygeodesy.fmath import cbrt, fremainder, norm2
+from pygeodesy.errors import GeodesicError, _ValueError, _xkwds
+from pygeodesy.fmath import cbrt, fremainder, norm2  # Fhorner, Fsum
 # from pygeodesy.internals import _version_info  # from .basics
 from pygeodesy.interns import NN, _2_, _a12_, _area_, _azi1_, _azi2_, _azi12_, \
                              _composite_, _lat1_, _lat2_, _lon1_, _lon2_, \
@@ -154,7 +156,8 @@ from pygeodesy.interns import NN, _2_, _a12_, _area_, _azi1_, _azi2_, _azi12_, \
                              _UNDER_, _X_,  _BAR_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
 from pygeodesy.named import ADict, _NamedBase, _NamedTuple, notImplemented, _Pass
-from pygeodesy.props import deprecated_method, Property_RO, property_ROnce
+from pygeodesy.props import deprecated_method, Property_RO, property_RO, \
+                                               property_ROnce
 from pygeodesy.units import Azimuth as _Azi, Degrees as _Deg, Lat, Lon, \
                             Meter as _M, Meter2 as _M2, Number_
 from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
@@ -162,9 +165,11 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '24.07.25'
+__version__ = '24.09.10'
 
-_K_2_0      = _getenv('PYGEODESY_GEOGRAPHICLIB', _2_) == _2_
+_K_2_0      = _getenv('PYGEODESY_GEOGRAPHICLIB', _2_)
+_K_2_4      = _K_2_0 == '2.4'
+_K_2_0      = _K_2_0 == _2_ or _K_2_4
 _perimeter_ = 'perimeter'
 
 
@@ -285,7 +290,7 @@ class Caps(object):
 
 Caps = Caps()  # PYCHOK singleton
 '''I{Enum}-style masks to be bit-C{or}'ed to specify geodesic or
-rhumb capabilities (C{caps}) and expected results (C{outmask}).
+rhumb capabilities (C{caps}) and results (C{outmask}).
 
 C{AREA} - compute area C{S12},
 
@@ -569,6 +574,11 @@ class _kWrapped(object):  # in .geodesicw
             M = None
         return M
 
+    @property_RO
+    def Math_K_2(self):
+        return ('_K_2_4' if _K_2_4 else
+               ('_K_2_0' if _K_2_0 else '_K_1_0')) if self.Math else NN
+
 _wrapped = _kWrapped()  # PYCHOK singleton, .datum, .test/base.py
 
 
@@ -805,25 +815,44 @@ def _polygon(geodesic, points, closed, line, wrap):
     return gP.Compute(False, True)[1 if line else 2]
 
 
+try:
+    from math import fma as _fma  # since 3.13
+
+    def _poly_fma(x, s, *cs):
+        for c in cs:
+            s = _fma(s, x, c)
+        return s
+
+except ImportError:  # Python 3.12-
+
+    def _poly_fma(x, s, *cs):  # PYCHOK redef
+        t = _0_0
+        for c in cs:
+            s, t, _ = _sum3(s * x, t * x, c)
+        return s + t
+
+#   def _poly_fma(x, *cs):
+#       S = Fhorner(x, *cs, incx=False)
+#       return float(S)
+
+#   def _poly_fma(x, s, *cs):  # scalar x, s, cs
+#       S = Fsum(s)._fma_scalar(None, x, *cs)
+#       return float(S)
+
 def _polynomial(x, cs, i, j):  # PYCHOK shared
     '''(INTERNAL) Like C++ C{GeographicLib.Math.hpp.polyval} but with a
-       different signature and cascaded summation as C{karney._sum2_}.
+       signature and cascaded summation different from C{karney._sum3}.
 
-       @return: M{sum(cs[k] * x**(j - k - 1) for k in range(i, j)}
+       @return: M{sum(x**(j - k - 1) * cs[k] for k in range(i, j)}
     '''
-    # assert 0 <= i <= j <= len(cs)
-#   try:
-#       return _wrapped.Math.polyval(j - i - 1, cs, i, x)
-#   except AttributeError:
-#       s, t = cs[i], _0_0
-#       for c in cs[i+1:j]:
-#           s, t = _sum2_(s * x, t * x, c)
-#       return s  # + t
-    s  = cs[i]
-    i += 1
-    if x and i < j:
-        s, _ = _sum2_(s, _0_0, x=x, *cs[i:j])
-    return s  # + t
+    if (i + 1) < j <= len(cs):  # load _Rtuple._tuple
+        try:
+            r = _wrapped.Math.polyval(j - i - 1, cs, i, x)
+        except AttributeError:
+            r = _poly_fma(x, *cs[i:j])
+    else:
+        r = cs[i]
+    return float(r)
 
 
 def _remainder(x, y):
@@ -875,67 +904,60 @@ def _sincos2de(deg, t):
         return sincos2d(deg, adeg=t)
 
 
-def _sum2(u, v):  # mimick geomath.Math.sum, actually sum2
+def _sum2(a, b):  # mimick geomath.Math.sum, actually sum2
     '''Error-free summation like C{geomath.Math.sum}.
 
-       @return: 2-Tuple C{(B{u} + B{v}, residual)}.
+       @return: 2-Tuple C{(B{a} + B{b}, residual)}.
 
-       @note: The C{residual} can be the same as B{C{u}} or B{C{v}}.
+       @note: The C{residual} can be the same as B{C{a}} or B{C{b}}.
 
-       @see: U{Algorithm 3.1<https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}.
+       @see: U{TwoSum<https://accurate-algorithms.readthedocs.io/en/latest/ch04summation.html>}
+             and I{Knuth}'s U{Algorithm 3.1<https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}.
     '''
     try:
-        return _wrapped.Math.sum(u, v)
+        return _wrapped.Math.sum(a, b)
     except AttributeError:
-        s = u + v
-        r = s - v
-        t = s - r
         # if Algorithm_3_1:
-        #   t = (u - t) + (v + r)
+        s = a + b
+        r = s - b
+        t = s - r
         # elif C_CPP:  # Math::sum C/C++
-        #   r -= u
-        #   t -= v
-        #   t += r
-        #   t = -t
+        #   r -= a; t -= b; t += r; t = -t
         # else:
-        t = (u - r) + (v - t)
+        t = (a - r) + (b - t)
+        # assert fabs(s) >= fabs(t)
         return s, t
 
 
-def _sum2_(s, t, *vs, **x):
-    '''Accumulate any B{C{vs}} into a previous C{_sum2(s, t)}.
-
-       @kwarg x: Optional polynomial C{B{x}=1} (C{scalar}).
+def _sum3(s, t, *xs):
+    '''Accumulate any B{C{xs}} into a previous C{_sum2(s, t)}.
 
-       @return: 2-Tuple C{(B{s} + B{t} + sum(B{vs}), residual)}.
+       @return: 3-Tuple C{(s, t, n)} where C{s} is the sum of B{s}, B{t} and all
+                B{xs}, C{t} the residual and C{n} the number of zero C{xs}.
 
        @see: I{Karney's} C++ U{Accumulator<https://GeographicLib.SourceForge.io/
              C++/doc/Accumulator_8hpp_source.html>} comments for more details and
              function C{_sum2} above.
 
-       @note: NOT "error-free", see C{pygeodesy.test/testKarney.py}.
+       @note: Not "error-free", see C{pygeodesy.test/testKarney.py}.
     '''
-    x = _xkwds_get1(x, x=_1_0)
-    p =  x != _1_0
-
-    _s2, _u0 = _sum2, unsigned0
-    for v in vs:
-        if p:
-            s *= x
-            t *= x
-        if v:
-            t, u = _s2(t, v)  # start at the least-
+    z = 0
+    for x in xs:
+        if x:
+            t, r = _sum2(t, x)  # start at the least-
             if s:
-                s, t = _s2(s, t)  # significant end
+                s, t = _sum2(s, t)  # -significant end
                 if s:
-                    t += u  # accumulate u into t
-#               elif t:  # s == 0 implies t == 0
-#                   raise _AssertionError(t=t, txt_not_=_0_)
+                    t += r  # accumulate r into t
                 else:
-                    s = _u0(u)  # result is u, t = 0
+                    # assert t == 0  # s == 0 implies t == 0
+                    s = unsigned0(r)  # result is r, t = 0
             else:
-                s, t = _u0(t), u
-    return s, t
+                s, t = unsigned0(t), r
+        else:
+            z += 1
+    # assert fabs(s) >= fabs(t)
+    return s, t, z
 
 
 def _tand(x):
@@ -955,7 +977,8 @@ def _unroll2(lon1, lon2, wrap=False):  # see .ellipsoidalBaseDI._intersects2
     '''
     if wrap:
         d, t = _diff182(lon1, lon2)
-        lon2, _ = _sum2_(d, t, lon1)  # (lon1 + d) + t
+        lon2, t, _ = _sum3(d, t, lon1)  # (lon1 + d) + t
+        lon2 += t
     else:
         lon2 = _norm180(lon2)
     return (lon2 - lon1), lon2

pygeodesy/ktm.py

@@ -67,7 +67,7 @@ from cmath import polar
 from math import atan2, asinh, cos, cosh, degrees, fabs, sin, sinh, sqrt, tanh
 
 __all__ = _ALL_LAZY.ktm
-__version__ = '24.07.16'
+__version__ = '24.08.31'
 
 
 class KTMError(_ValueError):
@@ -505,11 +505,11 @@ def _Xs(_Coeffs, m, E, RA=False):  # in .rhumb.ekx
         # constant, it cancels when evaluating a definite
         # integral.  Don't bother computing it, it is unused
         # in C{_Cyxgk4} above and C{rhumb.ekx._sincosSeries}.
-        _X, _p = X.append, _polynomial
-        i = (m + 2) if RA else 0
+        i  = (m + 2) if RA else 0
+        _p = _polynomial
         for r in _reverange(m):  # [m-1 ... 0]
             j = i + r + 1
-            _X(_p(n, Cs, i, j) * n_ / Cs[j])
+            X.append(_p(n, Cs, i, j) * n_ / Cs[j])
             i = j + 1
             n_ *= n
         X =  tuple(X)

pygeodesy/lazily.py

@@ -255,7 +255,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                           fmath=_i('Fdot', 'Fhorner', 'Fhypot', 'Fpolynomial', 'Fpowers', 'Fcbrt', 'Froot', 'Fsqrt',
                                    'bqrt', 'cbrt', 'cbrt2', 'euclid', 'euclid_',
                                    'facos1', 'fasin1', 'fatan', 'fatan1', 'fatan2', 'favg',
-                                   'fdot', 'fdot3', 'fmean', 'fmean_', 'fhorner', 'fidw', 'fpolynomial',
+                                   'fdot', 'fdot3', 'fma', 'fmean', 'fmean_', 'fhorner', 'fidw', 'fpolynomial',
                                    'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder',
                                    'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',
                                    'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'),
@@ -280,7 +280,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'FrechetVincentys', 'Frechet6Tuple',
                                    'frechet_'),
                          fstats=_i('Fcook', 'Flinear', 'Fwelford'),
-                          fsums=_i('Fsum', 'DivMod2Tuple', 'Fsum2Tuple', 'ResidualError',
+                          fsums=_i('Fsum', 'Fsum2product', 'DivMod2Tuple', 'Fsum2Tuple', 'ResidualError',
                                    'fsum', 'fsum_', 'fsumf_', 'fsum1', 'fsum1_', 'fsum1f_'),
                            gars=_i('Garef', 'GARSError'),
                       geodesici=_i('Intersectool', 'Intersectool5Tuple', 'Intersect7Tuple',
@@ -486,6 +486,11 @@ class _ALL_MODS(_internals._MODS_Base):
         except KeyError:
             return _getmodule(name, parent)
 
+    def imported(self, name):
+        '''Return module or package C{name} if already imported.
+        '''
+        return _sys.modules.get(name, None)
+
     def into(self, **mod_dunder_name_):
         '''Lazily import module C{mod} into module C{_dunder_name_}
            and set C{_dunder_name_._mod} to module C{mod}, I{once}.
@@ -521,7 +526,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.08.18'
+__version__ = '24.09.09'
 
 
 def _ALL_OTHER(*objs):

pygeodesy/mgrs.py

@@ -43,7 +43,7 @@ from pygeodesy.errors import _AssertionError, MGRSError, _parseX, \
 from pygeodesy.interns import NN, _0_, _A_, _AtoZnoIO_, _band_, _B_, \
                              _COMMASPACE_, _datum_, _easting_, _invalid_, \
                              _northing_, _SPACE_, _W_, _Y_, _Z_, _zone_
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYGEODESY_GEOCONVERT_
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name2__, _NamedBase, _NamedTuple, _Pass
 from pygeodesy.namedTuples import EasNor2Tuple, UtmUps5Tuple
 from pygeodesy.props import deprecated_property_RO, property_RO, Property_RO
@@ -55,7 +55,7 @@ from pygeodesy.utm import toUtm8, _to3zBlat, Utm, _UTM_ZONE_MAX, _UTM_ZONE_MIN
 # from pygeodesy.utmupsBase import _UTM_ZONE_MAX, _UTM_ZONE_MIN  # from .utm
 
 __all__ = _ALL_LAZY.mgrs
-__version__ = '24.06.11'
+__version__ = '24.09.04'
 
 _AN_    = 'AN'  # default south pole grid tile and band B
 _AtoPx_ = _AtoZnoIO_.tillP
@@ -652,51 +652,56 @@ def _um100km2(m):
 
 if __name__ == '__main__':
 
-    from pygeodesy.ellipsoidalVincenty import fabs, LatLon
-#   from pygeodesy.internals import printf  # from .lazily
-    from pygeodesy.lazily import _getenv,  printf
+    def _main():
 
-#   from math import fabs  # from .ellipsoidalVincenty
-    from os import access as _access, linesep as _NL, X_OK as _X_OK
+        from pygeodesy.ellipsoidalVincenty import fabs, LatLon
+        from pygeodesy.internals import _fper, printf
+        from pygeodesy.lazily import _getenv, _PYGEODESY_GEOCONVERT_
 
-    # <https://GeographicLib.sourceforge.io/C++/doc/GeoConvert.1.html>
-    _GeoConvert = _getenv(_PYGEODESY_GEOCONVERT_, '/opt/local/bin/GeoConvert')
-    if _access(_GeoConvert, _X_OK):
-        GC_m = _GeoConvert, '-m'  # -m converts latlon to MGRS
-        printf(' using: %s ...', _SPACE_.join(GC_m))
-        from pygeodesy.solveBase import _popen2
-    else:
-        GC_m = _popen2 = None
+#       from math import fabs  # from .ellipsoidalVincenty
+        from os import access as _access, linesep as _NL, X_OK as _X_OK
 
-    e = n = 0
-    try:
-        for lat in range(-90, 91, 1):
-            printf('%6s: lat %s ...', n, lat, end=NN, flush=True)
-            nl = _NL
-            for lon in range(-180, 181, 1):
-                m = LatLon(lat, lon).toMgrs()
-                if _popen2:
-                    t = '%s %s' % (lat, lon)
-                    g = _popen2(GC_m, stdin=t)[1]
-                    t =  m.toStr()  # sep=NN
-                    if t != g:
+        # <https://GeographicLib.sourceforge.io/C++/doc/GeoConvert.1.html>
+        _GeoConvert = _getenv(_PYGEODESY_GEOCONVERT_, '/opt/local/bin/GeoConvert')
+        if _access(_GeoConvert, _X_OK):
+            GC_m = _GeoConvert, '-m'  # -m converts latlon to MGRS
+            printf(' using: %s ...', _SPACE_.join(GC_m))
+            from pygeodesy.solveBase import _popen2
+        else:
+            GC_m = _popen2 = None
+
+        e = n = 0
+        try:
+            for lat in range(-90, 91, 1):
+                printf('%6s: lat %s ...', n, lat, end=NN, flush=True)
+                nl = _NL
+                for lon in range(-180, 181, 1):
+                    m = LatLon(lat, lon).toMgrs()
+                    if _popen2:
+                        t = '%s %s' % (lat, lon)
+                        g = _popen2(GC_m, stdin=t)[1]
+                        t =  m.toStr()  # sep=NN
+                        if t != g:
+                            e += 1
+                            printf('%s%6s: %s: %r vs %r (lon %s)', nl, -e, m, t, g, lon)
+                            nl = NN
+                    t = m.toLatLon(LatLon=LatLon)
+                    d = max(fabs(t.lat - lat), fabs(t.lon - lon))
+                    if d > 1e-9 and -90 < lat < 90 and -180 < lon < 180:
                         e += 1
-                        printf('%s%6s: %s: %r vs %r (lon %s)', nl, -e, m, t, g, lon)
+                        printf('%s%6s: %s: %s vs %s %.6e', nl, -e, m, t.latlon,
+                                                          (float(lat), float(lon)), d)
                         nl = NN
-                t = m.toLatLon(LatLon=LatLon)
-                d = max(fabs(t.lat - lat), fabs(t.lon - lon))
-                if d > 1e-9 and -90 < lat < 90 and -180 < lon < 180:
-                    e += 1
-                    printf('%s%6s: %s: %s vs %s %.6e', nl, -e, m, t.latlon, (float(lat), float(lon)), d)
-                    nl = NN
-                n += 1
-            if nl:
-                printf(' OK')
-    except KeyboardInterrupt:
-        printf(nl)
-
-    p = e * 100.0 / n
-    printf('%6s: %s errors (%.2f%%)', n, (e if e else 'no'), p)
+                    n += 1
+                if nl:
+                    printf(' OK')
+        except KeyboardInterrupt:
+            printf(nl)
+
+        printf('%6s: %s errors (%s)', n, (e if e else 'no'), _fper(e, n, prec=2))
+
+    _main()
+
 
 # % python3 -m pygeodesy.mgrs
 #  using: /opt/local/bin/GeoConvert -m ...

pygeodesy/named.py

@@ -34,7 +34,7 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.08.13'
+__version__ = '24.09.02'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -891,6 +891,9 @@ class _NamedEnumItem(_NamedBase):
                 raise _AssertionError(t)
 
 
+# from pygeodesy.props import _NamedProperty
+
+
 class _NamedTuple(tuple, _Named):
     '''(INTERNAL) Base for named C{tuple}s with both index I{and}
        attribute name access to the items.

pygeodesy/props.py

@@ -25,12 +25,11 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '24.07.23'
+__version__ = '24.09.02'
 
 _class_       = 'class'
 _dont_use_    = _DEPRECATED_ + ", don't use."
 _function_    = 'function'
-_get_and_set_ = 'get and set'
 _has_been_    = 'has been'  # PYCHOK used!
 _method_      = 'method'
 _not_an_inst_ = _not_(_an_, 'instance')
@@ -396,7 +395,9 @@ class property_ROver(_property_RO___):
     # No __doc__ on purpose
 
     def _fget(self, inst):
-        '''Get the C{property} value I{once} and overwrite C{self}, this C{property} instance.
+        '''Get the C{property} value I{once} and overwrite C{self},
+           this C{property} instance in the (super-)class of C{self}
+           where this property is define as a L{property_ROver}.
         '''
         v = self.method(inst)
         n = self.name
@@ -411,8 +412,8 @@ class property_ROver(_property_RO___):
         return v
 
 
-class _NamedProperty(property):
-    '''Class C{property} with retrievable name.
+class _NamedProperty(property):  # in .named
+    '''Class C{property} with a C{.name} attribute.
     '''
     @Property_RO
     def name(self):
@@ -445,7 +446,7 @@ def property_doc_(doc):
     def _documented_property(method):
         '''(INTERNAL) Return the documented C{property}.
         '''
-        t = _get_and_set_ if doc.startswith(_SPACE_) else NN
+        t = 'get and set' if doc.startswith(_SPACE_) else NN
         return _NamedProperty(method, None, None, NN('Property to ', t, doc))
 
     return _documented_property

pygeodesy/rhumb/__init__.py

@@ -9,7 +9,7 @@ u'''Package of lazily imported C{rhumb} modules L{rhumb.aux_}, L{rhumb.ekx} and
 from pygeodesy.lazily import _ALL_LAZY, _ALL_OTHER, _lazy_import_as, _unLazy0
 
 __all__ = _ALL_LAZY.rhumb
-__version__ = '24.06.18'
+__version__ = '24.09.02'
 
 if _unLazy0:  # or _isfrozen
     from pygeodesy.rhumb.aux_ import RhumbAux, RhumbLineAux