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

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/geodsolve.py

@@ -24,7 +24,7 @@ from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.07.11'
+__version__ = '24.08.13'
 
 
 class _GeodesicSolveBase(_SolveGDictBase):
@@ -101,8 +101,8 @@ class GeodesicSolve(_GeodesicSolveBase):
         '''Set up a L{GeodesicAreaExact} to compute area and perimeter
            of a polygon.
 
-           @kwarg polyline: If C{True} perimeter only, otherwise area
-                            and perimeter (C{bool}).
+           @kwarg polyline: If C{True}, compute the perimeter only, otherwise
+                            perimeter and area (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicAreaExact} instance.

pygeodesy/geohash.py

@@ -24,7 +24,7 @@ from pygeodesy.errors import _ValueError, _xkwds, _xStrError
 # from pygeodesy import formy as _formy  # _MODS
 from pygeodesy.interns import NN, _COMMA_, _DOT_, _E_, _height_, _N_, _NE_, \
                              _NW_, _radius_, _S_, _SE_, _SPACE_, _SW_, _W_, \
-                             _width_
+                             _width_  # _INV_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name__, _NamedDict, _NamedTuple, nameof, _xnamed
 from pygeodesy.namedTuples import Bounds2Tuple, Bounds4Tuple, LatLon2Tuple, \
@@ -38,7 +38,7 @@ from pygeodesy.units import Degrees_, Int, Lat_, Lon_, Meter, Precision_, Str
 from math import fabs, ldexp, log10, radians
 
 __all__ = _ALL_LAZY.geohash
-__version__ = '24.08.02'
+__version__ = '24.08.05'
 
 _formy   = _MODS.into(formy=__name__)
 _MASK5   =  16, 8, 4, 2, 1  # PYCHOK used!
@@ -118,8 +118,8 @@ def _2res(res, **prec):
     '''(INTERNAL) Get the C{res}olution for a C{prec}ision.
     '''
     p = max(min(Int(Error=GeohashError, **prec), _MaxPrec), 0) * 5
-    p = (p - p // 2) if res > _180_0 else (p // 2)
-    return ldexp(res, -p) if p else res
+    x = (p - p // 2) if res > _180_0 else (p // 2)
+    return ldexp(res, -x) if x else res  # ldexp == res / float(1 << x)
 
 
 class _GH(object):
@@ -231,7 +231,7 @@ class _GH(object):
         '''Decode C{geohash} into 4-tuple C{(s, w, n, e)}.
         '''
         nc = len(geohash) if isstr(geohash) else 0
-        if not (0 < nc <= _MaxPrec):
+        if not (0 < nc <= _MaxPrec):  # or geohash.startswith(_INV_)
             raise GeohashError(geohash=geohash, len=nc)
         s, w, n, e = self.SWNE4
         D, d, _mid = self.DecodeB32, True, _2mid
@@ -507,6 +507,13 @@ class Geohash(Str):
         '''
         return len(self)
 
+    @Property_RO
+    def resolution2(self):
+        '''Get the I{lon-} and I{latitudinal} resolution of this cell
+           in a L{Resolutions2Tuple}C{(res1, res2)}, both in C{degrees}.
+        '''
+        return resolution2(self.precision, self.precision)
+
     @deprecated_property_RO
     def sizes(self):
         '''DEPRECATED on 2024.07.28, use property C{Geohash.sizes3}.'''
@@ -515,11 +522,11 @@ class Geohash(Str):
 
     @Property_RO
     def sizes3(self):
-        '''Get the lat-, longitudinal and radial size of this cell as
-           a L{Sizes3Tuple}C{(height, width, radius)}, all C{meter}.
+        '''Get the lat-, longitudinal and radial size of this cell in
+           a L{Sizes3Tuple}C{(height, width, radius)}, all in C{meter}.
         '''
         z = _GH.Sizes
-        n =  min(len(z) - 1, max(self.precision, 1))
+        n =  min(max(self.precision, 1), len(z) - 1)
         return Sizes3Tuple(z[n], name=self.name)
 
     def toLatLon(self, LatLon=None, **LatLon_kwds):
@@ -650,7 +657,7 @@ class Geohashed(object):
     def _ab2round(self, *ll):
         '''(INTERNAL) Make encoded keys C{a, b}.
         '''
-        return map(round, ll, self._nn)
+        return map(round, ll, self._nn)  # strict=True
 
     def clear(self):
         '''Clear the C{en-} and C{decoded} cache.
@@ -1007,8 +1014,8 @@ def resolution2(prec1, prec2=None):
                      (C{int} 1..12).
 
        @return: L{Resolutions2Tuple}C{(res1, res2)} with the
-                (geographic) resolutions C{degrees}, where C{res2
-                B{is} res1} if no B{C{prec2}} is given.
+                (geographic) resolutions in C{degrees}, where
+                C{res2 B{is} res1} if no B{C{prec2}} is given.
 
        @raise GeohashError: Invalid B{C{prec1}} or B{C{prec2}}.