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

pygeodesy/geodesici.py

@@ -28,8 +28,9 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 from pygeodesy.basics import _copy, _enumereverse, map1, \
                              _xinstanceof, _xor
 from pygeodesy.constants import EPS, INF, INT0, PI, PI2, PI_4, \
-                               _0_0, _0_5, _1_0, _1_5, _2_0, _3_0, \
-                               _90_0, isfinite
+                               _0_0, _0_5, _1_0, _1_5, _2_0, \
+                               _3_0, _64_0, _90_0, isfinite, \
+                               _EPSjam  # PYCHOK used!
 from pygeodesy.ellipsoids import _EWGS84,  Fmt, unstr
 from pygeodesy.errors import GeodesicError, IntersectionError, _an, \
                             _xgeodesics, _xkwds_get, _xkwds_kwds, \
@@ -56,7 +57,7 @@ from pygeodesy.utily import sincos2,  atan2, fabs, radians
 # from math import atan2, ceil as _ceil, fabs, radians  # .fsums, .utily
 
 __all__ = _ALL_LAZY.geodesici
-__version__ = '24.07.25'
+__version__ = '24.08.28'
 
 _0t     =  0,  # int
 _1_1t   = -1, +1
@@ -1237,7 +1238,7 @@ class Intersector(_IntersectBase):
         return sx, zx, sAx, sBx
 
     def _polarB3(self, lats=False):  # PYCHOK no cover
-        latx =  64.0
+        latx = _64_0
         lat  = _90_0 - latx
         if self.f:
             _d, _pD2 =  fdot, self._polarDist2
@@ -1393,7 +1394,7 @@ class Intersector(_IntersectBase):
 
     @Property_RO
     def _Tol(self):  # convergence tolerance
-        return self._cHalf * pow(EPS, 0.75)  # _0_75
+        return self._cHalf * _EPSjam
 
     def toStr(self, **prec_sep_name):  # PYCHOK signature
         '''Return this C{Intersector} as string.

pygeodesy/geodesicx/_C4_24.py

@@ -13,7 +13,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 from pygeodesy.geodesicx.gxbases import _Gfloats, _f, _f2
 
 __all__ = ()
-__version__ = '23.08.19'
+__version__ = '24.09.04'
 
 _g = _Gfloats(24)
 _coeffs_24 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 24
@@ -1672,8 +1672,6 @@ _coeffs_24 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 24
     # C4[23], coeff of eps^23, polynomial in n of order 0
     _f(1 << 41), _f(0xc5e28ed2c935ab),  # PYCHOK exported
 ))  # 2900 / 2708
-if __name__ == '__main__':
-    _g.prints()
 del _g, _Gfloats, _f, _f2
 
 # **) MIT License

pygeodesy/geodesicx/_C4_27.py

@@ -13,7 +13,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 from pygeodesy.geodesicx.gxbases import _Gfloats, _f, _f2
 
 __all__ = ()
-__version__ = '23.08.19'
+__version__ = '24.09.04'
 
 _g = _Gfloats(27)
 _coeffs_27 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 27
@@ -2368,8 +2368,6 @@ _coeffs_27 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 27
     # C4[26], coeff of eps^26, polynomial in n of order 0
     _f(1 << 48), _f2(2126, 0x8c0e9e949456f),  # PYCHOK exported
 ))  # 4032 / 3764
-if __name__ == '__main__':
-    _g.prints()
 del _g, _Gfloats, _f, _f2
 
 # **) MIT License

pygeodesy/geodesicx/_C4_30.py

@@ -30,7 +30,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 from pygeodesy.geodesicx.gxbases import _Gfloats, _f, _f2
 
 __all__ = ()
-__version__ = '23.08.19'
+__version__ = '24.09.04'
 
 _g = _Gfloats(30)
 _coeffs_30 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 30
@@ -3273,8 +3273,6 @@ _coeffs_30 = _g((  # GEOGRAPHICLIB_GEODESICEXACT_ORDER == 30
     # C4[29], coeff of eps^29, polynomial in n of order 0
     _f(1 << 53), _f2(88602, 0xec373d36a45df),  # PYCHOK exported
 ))  # 5425 / 5107
-if __name__ == '__main__':
-    _g.prints()
 del _g, _Gfloats, _f, _f2
 
 

pygeodesy/geodesicx/__init__.py

@@ -23,7 +23,7 @@ from pygeodesy.karney import Caps, GeodesicError
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 
 __all__ = _ALL_LAZY.geodesicx + _ALL_DOCS(Caps, GeodesicError)
-__version__ = '24.07.09'
+__version__ = '24.09.06'
 
 # **) MIT License
 #

pygeodesy/geodesicx/__main__.py

@@ -5,65 +5,63 @@ u'''Print L{geodesicx} version, etc. using C{python -m pygeodesy.geodesicx}.
 '''
 
 __all__ = ()
-__version__ = '24.05.31'
+__version__ = '24.09.06'
 
 
-def _C4stats(nC4=None):  # PYCHOK no cover
-    '''(INTERNAL) Get the C{C4} stats.
-    '''
-    from pygeodesy import GeodesicExact, geodesicx
-
-    gX = GeodesicExact(C4order=nC4)
-    cs = geodesicx.gx._C4coeffs(gX.C4order)
-    ss = set(cs)  # without duplicates
-    pc = '%.1f%%' % (len(ss) * 100.0 / len(cs))
-    cx = gX._C4x
-    return dict(C4order=gX.C4order, C4len=len(cs), C4set=len(ss), C4set_len=pc, C4x=len(cx))
-
-
-def _main():  # PYCHOK no cover
-
-    import os.path as os_path
+def _main(**C4order):  # PYCHOK no cover
 
     try:
-        from pygeodesy import geodesicx as _gx, GeodesicError, \
-                              GeodesicSolve, printf, pygeodesy_abspath
-        from pygeodesy.internals import _Pythonarchine, _usage
-        from pygeodesy.interns import _COMMASPACE_, _DOT_, _SPACE_, _version_
-        from pygeodesy.streprs import Fmt
-
-        def _dot_attr(name, value):
-            return Fmt.DOT(Fmt.EQUAL(name, value))
-
-        s = tuple(sorted(_C4stats().items()))
-        p = [_dot_attr(*t) for t in (((_version_, _gx.__version__),) + s)]
-
-        def _name_version(pkg):
-            return _SPACE_(pkg.__name__, pkg.__version__)
-
-        v = _Pythonarchine()
+        from pygeodesy import GeodesicExact, geodesicx
+        from pygeodesy.internals import _fper, _name_version, \
+                                         printf, _sizeof, _versions
+        from pygeodesy.interns import _COMMASPACE_, _EQUAL_
         try:
-            import geographiclib
-            v.append(_name_version(geographiclib))
+            import numpy
         except ImportError:
-            pass
+            numpy = None
+
+        gX = GeodesicExact(**C4order)
+        cs = geodesicx.gx._C4coeffs(gX.C4order)
+        n  = len(cs)
+        u  = n         if numpy else len(set(cs))
+        z  = cs.nbytes if numpy else _sizeof(cs)
+        p  = dict(C4order=gX.C4order, C4n=n, C4u=u,
+                  C4u_n=_fper(u, n), C4x=len(gX._C4x),
+                  C4t=type(cs).__name__, C4z=z)
+        p  = list(_EQUAL_(*t) for t in p.items())
+        if numpy:
+            p.append(_name_version(numpy))
         try:
-            g = GeodesicSolve()
-            v.append(g.version)
-        except GeodesicError:
+            import geographiclib
+            p.append(_name_version(geographiclib))
+        except ImportError:
             pass
 
-        g = _gx.__name__
-        x =  os_path.basename(pygeodesy_abspath)
-        if not g.startswith(x):
-            g = _DOT_(x, g)
-        printf('%s%s (%s)', g, _COMMASPACE_.join(p), _COMMASPACE_.join(v))
+        g = _name_version(geodesicx)
+        printf('%s: %s (%s)', g, _COMMASPACE_.join(p), _versions())
 
     except ImportError:
-        printf(_usage(__file__))
+        from pygeodesy.internals import _usage
+        print(_usage(__file__))
+
+
+from sys import argv  # .internals._isPyChecker
+_main(C4order=int(argv[1])) if len(argv) == 2 and argv[1].isdigit() else _main()
+
+# % python3.13 -m pygeodesy.geodesicx 30
+# pygeodesy.geodesicx 24.09.06: C4order=30, C4n=5425, C4u=5107, C4u_n=94.1%, C4x=465, C4t=tuple, C4z=166008 (pygeodesy 24.9.6 Python 3.13.0rc1 64bit arm64 macOS 14.6.1)
+# % python3.12 -m pygeodesy.geodesicx 30
+# pygeodesy.geodesicx 24.09.06: C4order=30, C4n=5425, C4u=5425, C4u_n=100.0%, C4x=465, C4t=ndarray, C4z=43400, numpy 2.1.0, geographiclib 2.0 (pygeodesy 24.9.6 Python 3.12.5 64bit arm64 macOS 14.6.1)
 
+# % python3.13 -m pygeodesy.geodesicx 27
+# pygeodesy.geodesicx 24.09.06: C4order=27, C4n=4032, C4u=3764, C4u_n=93.4%, C4x=378, C4t=tuple, C4z=122632 (pygeodesy 24.9.6 Python 3.13.0rc1 64bit arm64 macOS 14.6.1)
+# % python3.12 -m pygeodesy.geodesicx 27
+# pygeodesy.geodesicx 24.09.06: C4order=27, C4n=4032, C4u=4032, C4u_n=100.0%, C4x=378, C4t=ndarray, C4z=32256, numpy 2.1.0, geographiclib 2.0 (pygeodesy 24.9.6 Python 3.12.5 64bit arm64 macOS 14.6.1)
 
-_main()
+# % python3.13 -m pygeodesy.geodesicx 24
+# pygeodesy.geodesicx 24.09.06: C4order=24, C4n=2900, C4u=2708, C4u_n=93.4%, C4x=300, C4t=tuple, C4z=88232 (pygeodesy 24.9.6 Python 3.13.0rc1 64bit arm64 macOS 14.6.1)
+# % python3.12 -m pygeodesy.geodesicx 24
+# pygeodesy.geodesicx 24.09.06: C4order=24, C4n=2900, C4u=2900, C4u_n=100.0%, C4x=300, C4t=ndarray, C4z=23200, numpy 2.1.0, geographiclib 2.0 (pygeodesy 24.9.6 Python 3.12.5 64bit arm64 macOS 14.6.1)
 
 # **) MIT License
 #

pygeodesy/geodesicx/gxarea.py

@@ -21,7 +21,7 @@ from pygeodesy.basics import isodd, unsigned0
 from pygeodesy.constants import NAN, _0_0, _0_5, _720_0
 # from pygeodesy.interns import _COMMASPACE_  # from .lazily
 from pygeodesy.karney import Area3Tuple, _diff182, GeodesicError, \
-                            _norm180, _remainder, _sum2_
+                            _norm180, _remainder, _sum3
 from pygeodesy.lazily import _ALL_DOCS, printf,  _COMMASPACE_
 from pygeodesy.named import ADict, callername, _NamedBase,  pairs
 from pygeodesy.props import Property, Property_RO, property_RO
@@ -30,7 +30,7 @@ from pygeodesy.props import Property, Property_RO, property_RO
 from math import fmod as _fmod
 
 __all__ = ()
-__version__ = '24.08.13'
+__version__ = '24.09.04'
 
 
 class GeodesicAreaExact(_NamedBase):
@@ -451,7 +451,7 @@ class _Accumulator(_NamedBase):
            @return: Current C{sum}.
         '''
         self._n += 1
-        self._s, self._t = _sum2_(self._s, self._t, y)
+        self._s, self._t, _ = _sum3(self._s, self._t, y)
         return self._s  # current .Sum()
 
     def Negate(self):

pygeodesy/geodesicx/gxbases.py

@@ -9,17 +9,18 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 '''
 
 from pygeodesy.basics import isodd,  _MODS
-from pygeodesy.constants import _EPSmin as _TINY, _0_0, _100_0
+from pygeodesy.constants import _EPSmin as _TINY, _0_0
 from pygeodesy.errors import _or, _xkwds_item2
 from pygeodesy.fmath import hypot as _hypot
+# from pygeodesy.interns import _numpy_  # _MODS
 from pygeodesy.karney import _CapsBase, GeodesicError, _2cos2x, \
-                             _norm2, _sincos2d, _sum2_
-# from pygeodesy.lazily import _MODS, printf  # .basics, _MODS
+                             _norm2, _sincos2d, _sum3
+# from pygeodesy.lazily import _ALL_MODS as _MODS  # from .basics
 
 from math import fabs, ldexp as _ldexp
 
 __all__ = ()
-__version__ = '24.06.16'
+__version__ = '24.09.07'
 
 # valid C{nC4}s and C{C4order}s, see _xnC4 below
 _nC4s = {24: 2900, 27: 4032, 30: 5425}
@@ -44,7 +45,7 @@ class _GeodesicBase(_CapsBase):  # in .geodsolve
 
 
 class _Gfloats(dict):
-    '''(INTERNAL) Uniquify floats.
+    '''(INTERNAL) Numpy or "Unique" floats.
     '''
     n   = 0  # total number of floats
     nC4 = 0
@@ -53,16 +54,16 @@ class _Gfloats(dict):
         self.nC4 = nC4
 
     def __call__(self, fs):
-        '''Return a tuple of "uniquified" floats.
+        '''Return a C{numpy.array} or C{tuple} of C{float}s.
         '''
+        np = _MODS.imported(_MODS.interns._numpy_)
+        if np:  # use numpy, already imported
+            cs = np.array(fs, dtype=float)
+        else:
+            _f = self.setdefault  # avoid duplicates
+            cs = tuple(_f(f, f) for f in map(float, fs))  # PYCHOK as attr
         self.n += len(fs)
-        _f = self.setdefault
-        return tuple(_f(f, f) for f in map(float, fs))  # PYCHOK as attr
-
-    def prints(self):
-        n, u = self.n, len(self.keys())
-        d = (n - u) * _100_0 / n
-        _MODS.lazily.printf('_CX_%d: n=%d, u=%d, d=%.1f%%', self.nC4, n, u, d)  # XXX
+        return cs
 
 
 def _cosSeries(c4s, sx, cx):  # PYCHOK shared .geodesicx.gx and -.gxline
@@ -75,15 +76,28 @@ def _cosSeries(c4s, sx, cx):  # PYCHOK shared .geodesicx.gx and -.gxline
     _c4 =  c4.pop
     if isodd(len(c4)):
         y0 = _c4()
-    _s2 = _sum2_
     while c4:
         # y1 = ar * y0 - y1 + c4.pop()
         # y0 = ar * y1 - y0 + c4.pop()
-        y1, t1 = _s2(ar * y0, ar * t0, -y1, -t1, _c4())
-        y0, t0 = _s2(ar * y1, ar * t1, -y0, -t0, _c4())
+        y1, t1, _ = _sum3(-y1, -t1, ar * y0, ar * t0, _c4())
+        y0, t0, _ = _sum3(-y0, -t0, ar * y1, ar * t1, _c4())
     # s  = (y0 - y1) * cx
-    s, _ = _s2(cx * y0, _0_0, cx * t0, -cx * y1, -cx * t1)
-    return s
+    s, t, _ = _sum3(cx * y0, _0_0, cx * t0, -cx * y1, -cx * t1)
+    return s + t
+
+#   Y0, Y1 = Fsum(), Fsum()
+#   ar  = _2cos2x(cx, sx)
+#   c4  =  list(c4s)
+#   _c4 =  c4.pop
+#   if isodd(len(c4)):
+#       Y0 += _c4()
+#   while c4:
+#       # y1 = ar * y0 - y1 + c4.pop()
+#       # y0 = ar * y1 - y0 + c4.pop()
+#       Y1 = Y0 * ar - Y1 + _c4()
+#       Y0 = Y1 * ar - Y0 + _c4()
+#   # s  = (y0 - y1) * cx
+#   return float((Y0 - Y1) * cx)
 
 
 _f = float  # in _f2 and .geodesicx._C4_24, _27 and _30

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__':