pygeodesy 24.5.24__py2.py3-none-any.whl → 24.6.9__py2.py3-none-any.whl

pygeodesy/fsums.py

@@ -25,11 +25,11 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import isbool, iscomplex, isint, isscalar, \
                             _signOf, itemsorted, signOf, _xiterable, \
-                            _enquote
+                            _xiterablen,  _enquote
 from pygeodesy.constants import INT0, _isfinite, NEG0, _pos_self, \
                                _0_0, _1_0, _N_1_0,  Float, Int
 from pygeodesy.errors import _OverflowError, _TypeError, _UnexpectedError, \
-                             _ValueError, _xError, _xError2, _xkwds_get, \
+                             _ValueError, _xError, _xError2, _xkwds_get1, \
                              _xkwds_pop2
 # from pygeodesy.internals import _enquote  # from .basics
 from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DASH_, _DOT_, \
@@ -40,14 +40,14 @@ from pygeodesy.lazily import _ALL_LAZY, _getenv, _sys_version_info2
 from pygeodesy.named import _name__, _name2__, _Named, _NamedTuple, \
                             _NotImplemented
 from pygeodesy.props import _allPropertiesOf_n, deprecated_property_RO, \
-                             Property_RO, property_RO
+                             Property, Property_RO, property_RO
 from pygeodesy.streprs import Fmt, fstr, unstr
 # from pygeodesy.units import Float, Int  # from .constants
 
 from math import ceil as _ceil, fabs, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '24.05.24'
+__version__ = '24.06.09'
 
 _add_op_      = _PLUS_  # in .auxilats.auxAngle
 _eq_op_       = _EQUAL_ * 2  # _DEQUAL_
@@ -1105,6 +1105,26 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
 #               raise self._Error(op, other, _AssertionError, txt__=signOf)
         return DivMod2Tuple(q, self)  # q is C{int} in Python 3+, but C{float} in Python 2-
 
+    def _fhorner(self, x, cs, op):  # in .fmath
+        '''(INTERNAL) Add an L{Fhorner} evaluation of polynomial
+           M{sum(cs[i] * x**i for i=0..len(cs)-1)}.
+        '''
+        if _xiterablen(cs):
+            H = Fsum(name__=self._fhorner)
+            if _isFsumTuple(x):
+                _mul = H._mul_Fsum
+            else:
+                _mul = H._mul_scalar
+                x = _2float(x=x)
+            if len(cs) > 1 and x:
+                for c in reversed(cs):
+                    H._fset_ps(_mul(x, op))
+                    H._fadd(c, op, up=False)
+            else:  # x == 0
+                H = cs[0]
+            self._fadd(H, op)
+        return self
+
     def _finite(self, other, op=None):
         '''(INTERNAL) Return B{C{other}} if C{finite}.
         '''
@@ -1149,7 +1169,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         '''
         return Fsum2Tuple(*self._fint2, **name)
 
-    @Property_RO
+    @Property
     def _fint2(self):  # see ._fset
         '''(INTERNAL) Get 2-tuple (C{int}, I{integer} residual).
         '''
@@ -1159,6 +1179,13 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         r = self._ps_1sum(i) if r and n > 1 else float(s - i)
         return i, (r or INT0)  # Fsum2Tuple?
 
+    @_fint2.setter_  # PYCHOK setter_underscore!
+    def _fint2(self, s):
+        '''(INTERNAL) Replace the C{_fint2} value.
+        '''
+        i = int(s)
+        return i, ((s - i) or INT0)
+
     @deprecated_property_RO
     def float_int(self):  # PYCHOK no cover
         '''DEPRECATED, use method C{Fsum.int_float}.'''
@@ -1243,7 +1270,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             f = self._pow(other, other, op, **raiser_RESIDUAL)
         return self._fset(f)  # n=max(len(self), 1)
 
-    @Property_RO
+    @Property
     def _fprs(self):
         '''(INTERNAL) Get and cache this instance' precision
            running sum (C{float} or C{int}), ignoring C{residual}.
@@ -1254,7 +1281,13 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         s, _ = self._fprs2
         return s  # ._fprs2.fsum
 
-    @Property_RO
+    @_fprs.setter_  # PYCHOK setter_underscore!
+    def _fprs(self, s):
+        '''(INTERNAL) Replace the C{_fprs} value.
+        '''
+        return s
+
+    @Property
     def _fprs2(self):
         '''(INTERNAL) Get and cache this instance' precision
            running sum and residual (L{Fsum2Tuple}).
@@ -1278,6 +1311,12 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         # assert self._ps is ps
         return Fsum2Tuple(s, r)
 
+    @_fprs2.setter_  # PYCHOK setter_underscore!
+    def _fprs2(self, s_r):
+        '''(INTERNAL) Replace the C{_fprs2} value.
+        '''
+        return Fsum2Tuple(s_r)
+
     def fset_(self, *xs):
         '''Replace this instance' value with all positional items.
 
@@ -1310,27 +1349,22 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             s = float(self._finite(other, **op)) if op else other
             self._ps[:] = s,
             self._n     = n or 1
-            if up:
-                i = int(s)  # see ._fint2
-                t = i, ((s - i) or INT0)
-                # Property_ROs _fint2, _fprs and _fprs2 can't be a Property:
-                # Property's _fset zaps the value just set by the @setter
-                self.__dict__.update(_fint2=t, _fprs=s, _fprs2=Fsum2Tuple(s, INT0))
+            if up:  # Property _fint2, _fprs and _fprs2 all have
+                # @.setter_underscore and NOT @.setter because the
+                # latter's _fset zaps the value set by @.setter
+                self._fint2 = s
+                self._fprs  = s
+                self._fprs2 = s, INT0
+                # assert self._fprs is s
         else:  # PYCHOK no cover
-            op = _xkwds_get(op, op=_fset_op_)
+            op = _xkwds_get1(op, op=_fset_op_)
             raise self._Error(op, other, _TypeError)
         return self
 
-    def _fset_ps(self, other, n=0):  # in .fmath
+    def _fset_ps(self, other):  # in .fmath
         '''(INTERNAL) Set partials from a known C{scalar}, L{Fsum} or L{Fsum2Tuple}.
         '''
-        if _isFsumTuple(other):
-            self._ps[:] = other._ps
-            self._n     = n or other._n
-        else:  # assert isscalar(other)
-            self._ps[:] = other,
-            self._n     = n or 1
-        return self
+        return self._fset(other, up=False)
 
     def fsub(self, xs=()):
         '''Subtract an iterable's items from this instance.
@@ -1765,7 +1799,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         return self._pow_2_3(s, x, other, op, **raiser_RESIDUAL)
 
     def _ps_acc(self, ps, xs, up=True, **unused):
-        '''(INTERNAL) Accumulate C{xs} scalars into list C{ps}.
+        '''(INTERNAL) Accumulate C{xs} known scalars into list C{ps}.
         '''
         n   =  0
         _2s = _2sum
@@ -2144,7 +2178,7 @@ try:
     # float.__getformat__('float')[:4] == 'IEEE'?)
     if _fsum((1, 1e101, 1, -1e101)) != 2:  # PYCHOK no cover
         del _fsum  # nope, remove _fsum ...
-        raise ImportError  # ... use _fsum below
+        raise ImportError()  # ... use _fsum below
 
     Fsum._math_fsum = _sum = _fsum  # PYCHOK exported
 except ImportError:
@@ -2192,7 +2226,7 @@ def fsum_(*xs, **floats):
 
        @see: Function L{fsum<fsums.fsum>} for further details.
     '''
-    return _fsum(xs if _xkwds_get(floats, floats=False) is True else
+    return _fsum(xs if _xkwds_get1(floats, floats=False) is True else
                 _2floats(xs, origin=1)) if xs else _0_0  # PYCHOK yield
 
 
@@ -2227,7 +2261,7 @@ def fsum1_(*xs, **floats):
 
        @see: Function L{fsum_<fsums.fsum_>} for further details.
     '''
-    return _fsum(_1primed(xs if _xkwds_get(floats, floats=False) is True else
+    return _fsum(_1primed(xs if _xkwds_get1(floats, floats=False) is True else
                          _2floats(xs, origin=1))) if xs else _0_0  # PYCHOK yield
 
 

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.05.24'
+__version__ = '24.05.31'
 
 # **) MIT License
 #

pygeodesy/geodesicx/__main__.py

@@ -5,7 +5,7 @@ u'''Print L{geodesicx} version, etc. using C{python -m pygeodesy.geodesicx}.
 '''
 
 __all__ = ()
-__version__ = '24.05.13'
+__version__ = '24.05.31'
 
 
 def _C4stats(nC4=None):  # PYCHOK no cover
@@ -88,4 +88,4 @@ _main()
 # OTHER DEALINGS IN THE SOFTWARE.
 
 # % python3 -m pygeodesy.geodesicx
-# pygeodesy.geodesicx.version=21.05.30, .C4Order=None, .C4len=5425, .C4set=5107, .C4set100=94, .C4x=465 (Python 3.9.5, 64bit, geographiclib 1.52)
+# pygeodesy.geodesicx.version=24.05.31, .C4len=5425, .C4order=30, .C4set=5107, .C4set_len=94.1%, .C4x=465 (Python 3.12.3, 64bit, arm64, geographiclib 2.0)

pygeodesy/geodesicx/gx.py

@@ -62,7 +62,7 @@ from pygeodesy.utily import atan2d as _atan2d_reverse, _unrollon, _Wrap, wrap360
 from math import atan2, copysign, cos, degrees, fabs, radians, sqrt
 
 __all__ = ()
-__version__ = '24.05.20'
+__version__ = '24.05.31'
 
 _MAXIT1 = 20
 _MAXIT2 = 10 + _MAXIT1 + MANT_DIG  # MANT_DIG == C++ digits
@@ -150,9 +150,7 @@ class GeodesicExact(_GeodesicBase):
            @raise GeodesicError: Invalid B{C{C4order}}.
         '''
         if name_C4Order:
-            C4Order, name = _xkwds_pop2(name_C4Order, C4Order=C4order)
-            if C4Order:  # for backward compatibility
-                self.C4order = C4Order
+            C4order, name = _xkwds_pop2(name_C4Order, C4Order=C4order)
             if name:
                 self.name = name
         else:
@@ -318,7 +316,7 @@ class GeodesicExact(_GeodesicBase):
         def _C4(nC4):
             i, n, cs = 0, self.n, _C4coeffs(nC4)
             _p = _polynomial
-            for r in range(nC4 + 1, 1, -1):
+            for r in range(nC4 + 1, 1, -1):  # _reverange
                 for j in range(1, r):
                     j = j + i  # (j - i - 1) order of polynomial
                     yield _p(n, cs, i, j) / cs[j]

pygeodesy/geodsolve.py

@@ -26,7 +26,7 @@ from pygeodesy.solveBase import _SolveBase, _SolveLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.05.23'
+__version__ = '24.06.04'
 
 
 class GeodSolve12Tuple(_GTuple):
@@ -59,11 +59,11 @@ class _GeodesicSolveBase(_SolveBase):
     def _cmdBasic(self):
         '''(INTERNAL) Get the basic C{GeodSolve} cmd (C{tuple}).
         '''
-        return (self.GeodSolve,) + self._b_option \
-                                 + self._e_option \
-                                 + self._E_option \
-                                 + self._p_option \
-                                 + self._u_option + ('-f',)
+        return (self.GeodSolve, '-f') + (self._b_option +
+                                         self._e_option +
+                                         self._E_option +
+                                         self._p_option +
+                                         self._u_option)
 
     @Property_RO
     def _E_option(self):
@@ -262,7 +262,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
         _xinstanceof(GeodesicSolve, geodesic=geodesic)
         if (caps & Caps.LINE_OFF):  # copy to avoid updates
             geodesic = geodesic.copy(deep=False, name=_UNDER_(NN, geodesic.name))  # NOT _under!
-        _SolveLineBase.__init__(self, geodesic, lat1, lon1, caps, name, azi1=azi1)
+        _SolveLineBase.__init__(self, geodesic, lat1, lon1, caps, azi1=azi1, **name)
         try:
             self.GeodSolve = geodesic.GeodSolve  # geodesic or copy of geodesic
         except GeodesicError:
@@ -362,49 +362,47 @@ if __name__ == '__main__':
     p = glS.ArcPosition(49.475527)
     printf('ArcPosition: %s %r', p == r, p)
 
-# % python3 -m pygeodesy.geodsolve
 
-# version: /opt/local/bin/GeodSolve: GeographicLib version 1.51
+# % python3 -m pygeodesy.geodsolve
 
-# version: /opt/local/bin/GeodSolve: GeographicLib version 1.51
+# version: /opt/local/bin/GeodSolve: GeographicLib version 2.2
 
-# Direct: GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
+# Direct: GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
 # Direct3: Destination3Tuple(lat=51.884565, lon=-1.141173, final=107.189397)
 
-# Inverse: GDict(M12=0.64473, M21=0.645046, S12=40041368848742.53125, a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, s12=5551759.400319)
+# Inverse: GDict(a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, M12=0.64473, M21=0.645046, s12=5551759.400319, S12=40041368848742.53125)
 # Inverse1: 49.94131021789904
 # Inverse3: Distance3Tuple(distance=5551759.400319, initial=51.198883, final=107.821777)
 
-# Position:    True  GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
-# ArcPosition: False GDict(M12=0.650911, M21=0.651229, S12=39735074737272.734375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, s12=5499999.948497)
+# Position:    True  GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
+# ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, M12=0.650911, M21=0.651229, s12=5499999.948497, S12=39735074737272.734375)
 
 
 # % python3 -m pygeodesy.geodsolve --verbose
 
 # GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve --version (invoke)
-# GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve: GeographicLib version 1.51 (0)
-# version: /opt/local/bin/GeodSolve: GeographicLib version 1.51
-# GeodesicSolve 'Test' 2: /opt/local/bin/GeodSolve -E -p 10 -f \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct)
+# GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve: GeographicLib version 2.2 (0)
+# version: /opt/local/bin/GeodSolve: GeographicLib version 2.2
+# GeodesicSolve 'Test' 2: /opt/local/bin/GeodSolve -f -E -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct)
 # GeodesicSolve 'Test' 2: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.0, lat2=51.884564505606761, lon2=-1.141172861200829, azi2=107.189397162605886, s12=5500000.0, a12=49.475527463251467, m12=4844148.703101486, M12=0.65091056699808603, M21=0.65122865892196558, S12=39735075134877.094 (0)
 
-# Direct: GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
-# GeodesicSolve 'Test' 3: /opt/local/bin/GeodSolve -E -p 10 -f \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct3)
+# Direct: GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
+# GeodesicSolve 'Test' 3: /opt/local/bin/GeodSolve -f -E -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct3)
 # GeodesicSolve 'Test' 3: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.0, lat2=51.884564505606761, lon2=-1.141172861200829, azi2=107.189397162605886, s12=5500000.0, a12=49.475527463251467, m12=4844148.703101486, M12=0.65091056699808603, M21=0.65122865892196558, S12=39735075134877.094 (0)
 # Direct3: Destination3Tuple(lat=51.884565, lon=-1.141173, final=107.189397)
-# GeodesicSolve 'Test' 4: /opt/local/bin/GeodSolve -E -p 10 -f -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse)
+# GeodesicSolve 'Test' 4: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse)
 # GeodesicSolve 'Test' 4: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186841, a12=49.941310217899037, m12=4877684.6027061976, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
 
-# Inverse: GDict(M12=0.64473, M21=0.645046, S12=40041368848742.53125, a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, s12=5551759.400319)
-# GeodesicSolve 'Test' 5: /opt/local/bin/GeodSolve -E -p 10 -f -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
+# Inverse: GDict(a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, M12=0.64473, M21=0.645046, s12=5551759.400319, S12=40041368848742.53125)
+# GeodesicSolve 'Test' 5: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
 # GeodesicSolve 'Test' 5: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186841, a12=49.941310217899037, m12=4877684.6027061976, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
 # Inverse1: 49.94131021789904
-# GeodesicSolve 'Test' 6: /opt/local/bin/GeodSolve -E -p 10 -f -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
+# GeodesicSolve 'Test' 6: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
 # GeodesicSolve 'Test' 6: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186841, a12=49.941310217899037, m12=4877684.6027061976, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
 # Inverse3: Distance3Tuple(distance=5551759.400319, initial=51.198883, final=107.821777)
 
-# Position:    True  GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
-# ArcPosition: False GDict(M12=0.650911, M21=0.651229, S12=39735074737272.734375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, s12=5499999.948497)
-
+# Position:    True  GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
+# ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, M12=0.650911, M21=0.651229, s12=5499999.948497, S12=39735074737272.734375)
 
 # **) MIT License
 #

pygeodesy/geohash.py

@@ -30,7 +30,7 @@ from pygeodesy.named import _name__, _NamedDict, _NamedTuple, nameof, _xnamed
 from pygeodesy.namedTuples import Bounds2Tuple, Bounds4Tuple, LatLon2Tuple, \
                                   PhiLam2Tuple
 from pygeodesy.props import deprecated_function, deprecated_method, \
-                            deprecated_property_RO, Property_RO, property_RO
+                            deprecated_property_RO, Property_RO
 from pygeodesy.streprs import fstr
 from pygeodesy.units import Degrees_, Int, Lat, Lon, Precision_, Str, \
                            _xStrError
@@ -38,7 +38,9 @@ from pygeodesy.units import Degrees_, Int, Lat, Lon, Precision_, Str, \
 from math import fabs, ldexp, log10, radians
 
 __all__ = _ALL_LAZY.geohash
-__version__ = '24.05.23'
+__version__ = '24.06.10'
+
+_formy = _MODS.into(formy=__name__)
 
 
 class _GH(object):
@@ -297,29 +299,28 @@ class Geohash(Str):
            using function L{pygeodesy.equirectangular}.
 
            @arg other: The other geohash (L{Geohash}, C{LatLon} or C{str}).
-           @kwarg radius: Mean earth radius, ellipsoid or datum
-                          (C{meter}, L{Ellipsoid}, L{Ellipsoid2},
-                          L{Datum} or L{a_f2Tuple}) or C{None}.
-           @kwarg adjust_limit_wrap: Optional keyword arguments for
-                               function L{pygeodesy.equirectangular_},
-                               overriding defaults C{B{adjust}=False,
-                               B{limit}=None} and C{B{wrap}=False}.
+           @kwarg radius: Mean earth radius, ellipsoid or datum (C{meter},
+                          L{Ellipsoid}, L{Ellipsoid2}, L{Datum} or
+                          L{a_f2Tuple}) or C{None}, see function
+                          L{pygeodesy.equirectangular}.
+           @kwarg adjust_limit_wrap: Optional keyword arguments for function
+                         L{pygeodesy.equirectangular4}, overriding defaults
+                         C{B{adjust}=False, B{limit}=None} and C{B{wrap}=False}.
 
            @return: Distance (C{meter}, same units as B{C{radius}} or the
                     ellipsoid or datum axes or C{radians I{squared}} if
                     B{C{radius}} is C{None} or C{0}).
 
-           @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon}
-                             or C{str} or invalid B{C{radius}}.
+           @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon} or
+                             C{str} or invalid B{C{radius}}.
 
            @see: U{Local, flat earth approximation
                  <https://www.EdWilliams.org/avform.htm#flat>}, functions
         '''
         lls  =  self.latlon + _2Geohash(other).latlon
         kwds = _xkwds(adjust_limit_wrap, adjust=False, limit=None, wrap=False)
-        m    =  self._formy
-        return m.equirectangular( *lls, radius=radius, **kwds) if radius else \
-               m.equirectangular_(*lls, **kwds).distance2
+        return _formy.equirectangular( *lls, radius=radius, **kwds) if radius else \
+               _formy.equirectangular4(*lls, **kwds).distance2
 
     def euclideanTo(self, other, **radius_adjust_wrap):
         '''Approximate the distance between this and an other geohash using
@@ -335,14 +336,7 @@ class Geohash(Str):
            @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon}
                              or C{str} or invalid B{C{radius}}.
         '''
-        return self._distanceTo(self._formy.euclidean, other, **radius_adjust_wrap)
-
-    @property_RO
-    def _formy(self):
-        '''(INTERNAL) Get the C{.formy} module, I{once}.
-        '''
-        Geohash._formy = f = _MODS.formy  # overwrite property_RO
-        return f
+        return self._distanceTo(_formy.euclidean, other, **radius_adjust_wrap)
 
     def haversineTo(self, other, **radius_wrap):
         '''Compute the distance between this and an other geohash using
@@ -358,7 +352,7 @@ class Geohash(Str):
            @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon}
                              or C{str} or invalid B{C{radius}}.
         '''
-        return self._distanceTo(self._formy.haversine, other, **radius_wrap)
+        return self._distanceTo(_formy.haversine, other, **radius_wrap)
 
     @Property_RO
     def latlon(self):
@@ -431,7 +425,7 @@ class Geohash(Str):
            @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon}
                              or C{str} or invalid B{C{radius}}.
         '''
-        return self._distanceTo(self._formy.vincentys, other, **radius_wrap)
+        return self._distanceTo(_formy.vincentys, other, **radius_wrap)
 
     @Property_RO
     def N(self):
@@ -645,8 +639,8 @@ def distance1(geohash1, geohash2):
 
 @deprecated_function
 def distance2(geohash1, geohash2):
-    '''DEPRECATED, use L{geohash.equirectangular_}.'''
-    return equirectangular_(geohash1, geohash2)
+    '''DEPRECATED, use L{geohash.equirectangular4}.'''
+    return equirectangular4(geohash1, geohash2)
 
 
 @deprecated_function
@@ -718,7 +712,7 @@ def encode(lat, lon, precision=None):
     return NN.join(gh)
 
 
-def equirectangular_(geohash1, geohash2, radius=R_M):
+def equirectangular4(geohash1, geohash2, radius=R_M):
     '''Approximate the distance between two geohashes using the
        L{pygeodesy.equirectangular} formula.
 
@@ -803,18 +797,11 @@ def precision(res1, res2=None):
              <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Geohash.html>}.
     '''
     r = Degrees_(res1=res1, low=_0_0, Error=GeohashError)
-    if res2 is None:
-        t = r, r
-        for p in range(1, _MaxPrec):
-            if resolution2(p, None) <= t:
-                return p
-
-    else:
-        t = r, Degrees_(res2=res2, low=_0_0, Error=GeohashError)
-        for p in range(1, _MaxPrec):
-            if resolution2(p, p) <= t:
-                return p
-
+    N = res2 is None
+    t = r, (r if N else Degrees_(res2=res2, low=_0_0, Error=GeohashError))
+    for p in range(1, _MaxPrec):
+        if resolution2(p, (None if N else p)) <= t:
+            return p
     return _MaxPrec
 
 
@@ -891,7 +878,7 @@ def vincentys_(geohash1, geohash2, **radius_wrap):
 
 __all__ += _ALL_OTHER(bounds,  # functions
                       decode, decode2, decode_error, distance_,
-                      encode, equirectangular_, euclidean_, haversine_,
+                      encode, equirectangular4, euclidean_, haversine_,
                       neighbors, precision, resolution2, sizes, vincentys_)
 
 # **) MIT License

pygeodesy/geoids.py

@@ -118,7 +118,7 @@ except ImportError:  # Python 3+
     from io import BytesIO as _BytesIO  # PYCHOK expected
 
 __all__ = _ALL_LAZY.geoids
-__version__ = '24.05.23'
+__version__ = '24.06.03'
 
 _assert_ = 'assert'
 _bHASH_  =  b'#'

pygeodesy/hausdorff.py

@@ -77,7 +77,7 @@ from pygeodesy.lazily import _ALL_LAZY, _FOR_DOCS
 from pygeodesy.named import _name2__, _Named, _NamedTuple, _Pass
 # from pygeodesy.namedTuples import PhiLam2Tuple  # from .points
 from pygeodesy.points import _distanceTo, points2 as _points2,  PhiLam2Tuple, radians
-from pygeodesy.props import Property_RO, property_doc_, property_RO
+from pygeodesy.props import Property, Property_RO, property_doc_, property_RO
 from pygeodesy.units import Float, Number_, _xUnit, _xUnits
 from pygeodesy.unitsBase import _Str_degrees, _Str_degrees2, _Str_meter, _Str_NN, \
                                 _Str_radians, _Str_radians2
@@ -86,7 +86,7 @@ from pygeodesy.unitsBase import _Str_degrees, _Str_degrees2, _Str_meter, _Str_NN
 from random import Random
 
 __all__ = _ALL_LAZY.hausdorff
-__version__ = '24.05.24'
+__version__ = '24.06.08'
 
 
 class HausdorffError(PointsError):
@@ -179,14 +179,14 @@ class Hausdorff(_Named):
         return self._func(point1.lat, point1.lon,
                           point2.lat, point2.lon, **self._kwds)
 
-    @property
+    @Property
     def _func(self):
         '''(INTERNAL) I{Must be overloaded}.'''
-        return _formy._Propy(self, 0, _func=None)
+        self._notOverloaded(**self.kwds)
 
-    @_func.setter  # PYCHOK setter!
+    @_func.setter_  # PYCHOK setter_underscore!
     def _func(self, func):
-        _formy._Propy(self, 4, _func=func)
+        return _formy._Propy(func, 4, self.kwds)
 
     def _hausdorff_(self, point2s, both, early, distance):
         _, ps2 = self._points2(point2s)
@@ -341,14 +341,14 @@ class _HausdorffMeterRadians(Hausdorff):
         '''
         return self._hausdorff_(point2s, True, early, _formy._radistance(self))
 
-    @property
+    @Property
     def _func_(self):
         '''(INTERNAL) I{Must be overloaded}.'''
-        return _formy._Propy(self, 0, _func_=None)
+        self._notOverloaded(**self.kwds)
 
-    @_func_.setter  # PYCHOK setter!
+    @_func_.setter_  # PYCHOK setter_underscore!
     def _func_(self, func):
-        _formy._Propy(self, 3,_func_=func)
+        return _formy._Propy(func, 3, self.kwds)
 
 
 class HausdorffCosineAndoyerLambert(_HausdorffMeterRadians):
@@ -462,7 +462,7 @@ class HausdorffDistanceTo(Hausdorff):
 
 class HausdorffEquirectangular(Hausdorff):
     '''Compute the C{Hausdorff} distance based on the C{equirectangular} distance
-       in C{radians squared} like function L{pygeodesy.equirectangular_}.
+       in C{radians squared} like function L{pygeodesy.equirectangular}.
     '''
     _units = _Str_degrees2
 
@@ -471,7 +471,7 @@ class HausdorffEquirectangular(Hausdorff):
 
            @kwarg seed_name__adjust_limit_wrap: Optional C{B{seed}=None} and
                              C{B{name}=NN} and keyword arguments for function
-                             L{pygeodesy.equirectangular_} I{with default}
+                             L{pygeodesy.equirectangular} I{with default}
                              C{B{limit}=0} for I{backward compatibility}.
 
            @see: L{Hausdorff.__init__} for details about B{C{point1s}},
@@ -819,14 +819,13 @@ class Hausdorff6Tuple(_NamedTuple):
     _Names_ = ('hd', _i_,     _j_,     'mn',     'md',  _units_)
     _Units_ = (_Pass, Number_, Number_, Number_, _Pass, _Pass)
 
-    def toUnits(self, **Error):  # PYCHOK expected
+    def toUnits(self, **Error_name):  # PYCHOK expected
         '''Overloaded C{_NamedTuple.toUnits} for C{hd} and C{md} units.
         '''
-        U = _xUnit(self.units, Float)  # PYCHOK expected
-        M = _Pass if self.md is None else U  # PYCHOK expected
-        self._Units_ = (U,) + Hausdorff6Tuple._Units_[1:4] \
-                     + (M,) + Hausdorff6Tuple._Units_[5:]
-        return _NamedTuple.toUnits(self, **Error)
+        u    = list(Hausdorff6Tuple._Units_)
+        u[0] = U = _xUnit(self.units, Float)  # PYCHOK expected
+        u[4] =     _Pass if self.md is None else U  # PYCHOK expected
+        return _NamedTuple.toUnits(self.reUnit(*u), **Error_name)  # PYCHOK self
 
 
 def randomrangenerator(seed):