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

pygeodesy/ellipsoids.py

@@ -80,11 +80,12 @@ from pygeodesy.interns import NN, _a_, _Airy1830_, _AiryModified_, _b_, _Bessel1
                              _prime_vertical_, _radius_, _Sphere_, _SPACE_, _vs_, _WGS72_, _WGS84_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
 from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _name2__, _NamedEnum, \
-                                _NamedEnumItem, _NamedTuple, _Pass,  _ALL_LAZY,  _MODS
+                                _NamedEnumItem, _NamedTuple, _Pass,  _ALL_LAZY, _MODS
 from pygeodesy.namedTuples import Distance2Tuple, Vector3Tuple, Vector4Tuple
 from pygeodesy.props import deprecated_Property_RO, Property_RO, property_doc_, \
                             deprecated_property_RO, property_RO
 from pygeodesy.streprs import Fmt, fstr, instr, strs, unstr
+# from pygeodesy.triaxials import _hartzell3  # _MODS
 from pygeodesy.units import Bearing_, Distance, Float, Float_, Height, Lam_, Lat, Meter, \
                             Meter2, Meter3, Phi, Phi_, Radius, Radius_, Scalar
 from pygeodesy.utily import atan1, atan1d, atan2b, degrees90, m2radians, radians2m, sincos2d
@@ -92,7 +93,7 @@ from pygeodesy.utily import atan1, atan1d, atan2b, degrees90, m2radians, radians
 from math import asinh, atan, atanh, cos, degrees, exp, fabs, radians, sin, sinh, sqrt, tan
 
 __all__ = _ALL_LAZY.ellipsoids
-__version__ = '24.05.21'
+__version__ = '24.05.28'
 
 _f_0_0    = Float(f =_0_0)  # zero flattening
 _f__0_0   = Float(f_=_0_0)  # zero inverse flattening
@@ -1101,7 +1102,7 @@ class Ellipsoid(_NamedEnumItem):
                  methods L{Ellipsoid.height4} and L{Triaxial.hartzell4}.
         '''
         try:
-            v, d = _MODS.triaxials._hartzell2(pov, los, self._triaxial)
+            v, d, _ = _MODS.triaxials._hartzell3(pov, los, self._triaxial)
         except Exception as x:
             raise IntersectionError(pov=pov, los=los, cause=x)
         return Vector4Tuple(v.x, v.y, v.z, d, name__=self.hartzell4)
@@ -1643,9 +1644,9 @@ class Ellipsoid(_NamedEnumItem):
             r = self.e2s2(sin(a))
             if r > EPS02:
                 n = self.a / sqrt(r)
-                m = n * self.e21 / r  # PYCHOK attr
+                m = n * self.e21 / r
             else:
-                m = n = _0_0  # PYCHOK attr
+                m = n = _0_0
         else:
             m = n = self.a
         if scaled and a:

pygeodesy/errors.py

@@ -26,7 +26,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.05.19'
+__version__ = '24.06.08'
 
 _argument_   = 'argument'
 _box_        = 'box'
@@ -43,7 +43,7 @@ try:
 
     if _PYTHON_X_DEV or _getenv('PYGEODESY_EXCEPTION_CHAINING', NN):  # == _std_
         _exception_chaining = True  # turned on, std
-        raise AttributeError  # allow exception chaining
+        raise AttributeError()  # allow exception chaining
 
     _exception_chaining = False  # turned off
 
@@ -252,7 +252,7 @@ class LenError(_ValueError):  # in .ecef, .fmath, .heights, .iters, .named
 class LimitError(_ValueError):
     '''Error raised for lat- or longitudinal values or deltas exceeding
        the given B{C{limit}} in functions L{pygeodesy.equirectangular},
-       L{pygeodesy.equirectangular_}, C{nearestOn*} and C{simplify*}
+       L{pygeodesy.equirectangular4}, C{nearestOn*} and C{simplify*}
        or methods with C{limit} or C{options} keyword arguments.
 
        @see: Subclass L{UnitError}.
@@ -748,8 +748,8 @@ def _xkwds_get(kwds, **name_default):
        C{default} if not present.
     '''
     if isinstance(kwds, dict) and len(name_default) == 1:
-        for n, d in name_default.items():
-            return kwds.get(n, d)
+        for n, v in name_default.items():
+            return kwds.get(n, v)
     raise _xAssertionError(_xkwds_get, kwds, **name_default)
 
 
@@ -759,8 +759,18 @@ def _xkwds_get_(kwds, **names_defaults):
     '''
     if not isinstance(kwds, dict):
         raise _xAssertionError(_xkwds_get_, kwds)
-    for n, d in _MODS.basics.itemsorted(names_defaults):
-        yield kwds.get(n, d)
+    for n, v in _MODS.basics.itemsorted(names_defaults):
+        yield kwds.get(n, v)
+
+
+def _xkwds_get1(kwds, **name_default):
+    '''(INTERNAL) Get one C{kwds} value by C{name} or the
+       C{default} if not present.
+    '''
+    v, kwds = _xkwds_pop2(kwds, **name_default)
+    if kwds:
+        raise _UnexpectedError(**kwds)
+    return v
 
 
 def _xkwds_item2(kwds):
@@ -784,11 +794,11 @@ def _xkwds_pop2(kwds, **name_default):
        reduced C{kwds} copy, otherwise the C{default} and original C{kwds}.
     '''
     if isinstance(kwds, dict) and len(name_default) == 1:
-        for n, d in name_default.items():
+        for n, v in name_default.items():
             if n in kwds:
                 kwds = _copy(kwds)
-                d = kwds.pop(n, d)
-            return d, kwds
+                v = kwds.pop(n, v)
+            return v, kwds
     raise _xAssertionError(_xkwds_pop2, kwds, **name_default)
 
 

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.05.24'
+__version__ = '24.05.31'
 
 _OVERFLOW = _1_EPS**2  # about 2e+31
 _TAYTOL   =  pow(EPS, 0.6)
@@ -101,12 +101,6 @@ _TOL_10   =  EPS * _0_1
 _TRIPS    =  21  # C++ 10
 
 
-def _overflow(x):
-    '''(INTERNAL) Like C{copysign0(OVERFLOW, B{x})}.
-    '''
-    return _copyBit(_OVERFLOW, x)
-
-
 class ETMError(UTMError):
     '''Exact Transverse Mercator (ETM) parse, projection or other
        L{Etm} issue or L{ExactTransverseMercator} conversion failure.
@@ -160,17 +154,15 @@ class Etm(Utm):
     def parse(self, strETM, **name):
         '''Parse a string to a similar L{Etm} instance.
 
-           @arg strETM: The ETM coordinate (C{str}), see function
-                        L{parseETM5}.
-           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding
-                        this name.
+           @arg strETM: The ETM coordinate (C{str}), see function L{parseETM5}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The instance (L{Etm}).
 
            @raise ETMError: Invalid B{C{strETM}}.
 
-           @see: Function L{pygeodesy.parseUPS5}, L{pygeodesy.parseUTM5}
-                 and L{pygeodesy.parseUTMUPS5}.
+           @see: Function L{pygeodesy.parseUPS5}, L{pygeodesy.parseUTM5} and
+                 L{pygeodesy.parseUTMUPS5}.
         '''
         return parseETM5(strETM, datum=self.datum, Etm=self.classof,
                                  name=self._name__(name))
@@ -217,9 +209,7 @@ class Etm(Utm):
         lat, lon, g, k = xTM.reverse(e, n, lon0=lon0)
 
         ll = _LLEB(lat, lon, datum=d, name=self.name)  # utm._LLEB
-        ll._gamma = g
-        ll._scale = k
-        self._latlon5args(ll, _toBand, unfalse, xTM)
+        self._latlon5args(ll, g, k, _toBand, unfalse, xTM)
 
     def toUtm(self):  # PYCHOK signature
         '''Copy this ETM to a UTM coordinate.
@@ -1032,6 +1022,12 @@ class ExactTransverseMercator(_NamedBase):
         return g_k  # or (g, k, lat, lon)
 
 
+def _overflow(x):
+    '''(INTERNAL) Like C{copysign0(OVERFLOW, B{x})}.
+    '''
+    return _copyBit(_OVERFLOW, x)
+
+
 def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, **name):
     '''Parse a string representing a UTM coordinate, consisting
        of C{"zone[band] hemisphere easting northing"}.
@@ -1058,8 +1054,7 @@ def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, **name):
 
 
 def toEtm8(latlon, lon=None, datum=None, Etm=Etm, falsed=True,
-                                         strict=True, zone=None,
-                                         **name_cmoff):
+                             strict=True, zone=None, **name_cmoff):
     '''Convert a geodetic lat-/longitude to an ETM coordinate.
 
        @arg latlon: Latitude (C{degrees}) or an (ellipsoidal)
@@ -1075,9 +1070,9 @@ def toEtm8(latlon, lon=None, datum=None, Etm=Etm, falsed=True,
        @kwarg strict: Restrict B{C{lat}} to UTM ranges (C{bool}).
        @kwarg zone: Optional UTM zone to enforce (C{int} or C{str}).
        @kwarg name_cmoff: Optional B{C{Etm}} C{B{name}=NN} (C{str})
-                   and DEPRECATED C{B{cmoff}=True} to offset longitude
-                   from the zone's central meridian (C{bool}), instead
-                   use C{B{falsed}=True}.
+                   and DEPRECATED keyword argument C{B{cmoff}=True}
+                   to offset the longitude from the zone's central
+                   meridian (C{bool}), use B{C{falsed}} instead.
 
        @return: The ETM coordinate as an B{C{Etm}} instance or a
                 L{UtmUps8Tuple}C{(zone, hemipole, easting, northing,

pygeodesy/fmath.py

@@ -12,7 +12,7 @@ from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
                                _0_0, _0_125, _1_6th, _0_25, _1_3rd, _0_5, _1_0, \
                                _N_1_0, _1_5, _copysign_0_0, _isfinite, remainder
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
-                             _xError, _xkwds_get, _xkwds_pop2
+                             _xError, _xkwds_get1, _xkwds_pop2
 from pygeodesy.fsums import _2float, Fsum, fsum, fsum1_, _isFsumTuple, _1primed, \
                              Fmt, unstr
 from pygeodesy.interns import MISSING, _negative_, _not_scalar_
@@ -24,7 +24,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '24.05.24'
+__version__ = '24.05.29'
 
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ... sqrt(2) - 1
@@ -85,19 +85,7 @@ class Fhorner(Fsum):
         '''
         Fsum.__init__(self, **name_RESIDUAL)
         if cs:
-            if _isFsumTuple(x):
-                _mul = self._mul_Fsum
-            else:
-                _mul = self._mul_scalar
-                x = _2float(x=x)
-            op = Fhorner.__name__
-            if len(cs) > 1 and x:
-                for c in reversed(cs):
-                    self._fset_ps(_mul(x, op))
-                    self._fadd(c, op, up=False)
-                self._update()
-            else:  # x == 0
-                self._fadd(cs[0], op)
+            self._fhorner(x, cs, Fhorner.__name__)
         else:
             self._fset_ps(_0_0)
 
@@ -343,8 +331,9 @@ def facos1(x):
     if a < EPS0:
         r = PI_2
     elif a < EPS1:
-        H = Fhorner(-a, 1.5707288, 0.2121144, 0.0742610, 0.0187293)
-        r = float(H * sqrt(_1_0 - a))
+        H  = Fhorner(-a, 1.5707288, 0.2121144, 0.0742610, 0.0187293)
+        H *= Fsqrt(_1_0, -a)
+        r  = float(H)
         if x < 0:
             r = PI - r
     else:
@@ -376,7 +365,7 @@ def fatan(x):
 
 
 def fatan1(x):
-    '''Fast approximation of C{atan(B{x})} for C{0 <= B{x} <= 1}, I{unchecked}.
+    '''Fast approximation of C{atan(B{x})} for C{0 <= B{x} < 1}, I{unchecked}.
 
        @see: U{ShaderFastLibs.h<https://GitHub.com/michaldrobot/ShaderFastLibs/
              blob/master/ShaderFastMathLib.h>} and U{Efficient approximations
@@ -385,7 +374,7 @@ def fatan1(x):
              IEEE Signal Processing Magazine, 111, May 2006.
     '''
     # Eq (9): PI_4 * x - x * (abs(x) - 1) * (0.2447 + 0.0663 * abs(x)), for -1 < x < 1
-    #         PI_4 * x - (x**2 - x) * (0.2447 + 0.0663 * x), for 0 < x - 1
+    #         PI_4 * x - (x**2 - x) * (0.2447 + 0.0663 * x), for 0 < x < 1
     #         x * (1.0300981633974482 + x * (-0.1784 - x * 0.0663))
     H = Fhorner(x, _0_0, 1.0300981634, -0.1784, -0.0663)
     return float(H)
@@ -597,7 +586,7 @@ def fpolynomial(x, *cs, **over):
        @see: Class L{Fpolynomial} for further details.
     '''
     P =  Fpolynomial(x, *cs)
-    d = _xkwds_get(over, over=0) if over else 0
+    d = _xkwds_get1(over, over=0) if over else 0
     return P.fover(d) if d else float(P)
 
 

pygeodesy/formy.py

@@ -8,7 +8,7 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 # from pygeodesy.cartesianBase import CartesianBase  # _MODS
 from pygeodesy.constants import EPS, EPS0, EPS1, PI, PI2, PI3, PI_2, R_M, \
-                               _umod_PI2, float0_, isnon0, remainder, \
+                               _0_0s, float0_, isnon0, remainder, _umod_PI2, \
                                _0_0, _0_125, _0_25, _0_5, _1_0, _2_0, _4_0, \
                                _32_0, _90_0, _180_0, _360_0
 from pygeodesy.datums import Datum, Ellipsoid, _ellipsoidal_datum, \
@@ -16,18 +16,18 @@ from pygeodesy.datums import Datum, Ellipsoid, _ellipsoidal_datum, \
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
 from pygeodesy.errors import IntersectionError, LimitError, limiterrors, \
                             _TypeError, _ValueError, _xattr, _xError, \
-                            _xkwds, _xkwds_pop2
+                            _xcallable,_xkwds, _xkwds_pop2
 from pygeodesy.fmath import euclid, hypot, hypot2, sqrt0
 from pygeodesy.fsums import fsumf_,  Fmt, unstr
 # from pygeodesy.internals import _dunder_nameof  # from .named
-from pygeodesy.interns import _delta_, _distant_, _inside_, _not_, _SPACE_, _too_
+from pygeodesy.interns import _delta_, _distant_, _inside_, _SPACE_, _too_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name__, _name2__, _NamedTuple, _xnamed, \
                             _dunder_nameof
 from pygeodesy.namedTuples import Bearing2Tuple, Distance4Tuple, LatLon2Tuple, \
                                   Intersection3Tuple, PhiLam2Tuple, Vector3Tuple
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
-# from pygeodesy.triaxials import _hartzell2  # _MODS
+# from pygeodesy.triaxials import _hartzell3  # _MODS
 from pygeodesy.units import _isHeight, _isRadius, Bearing, Degrees_, Distance, \
                              Distance_, Height, Lam_, Lat, Lon, Meter_,  Phi_, \
                              Radians, Radians_, Radius, Radius_, Scalar, _100km
@@ -42,7 +42,7 @@ from contextlib import contextmanager
 from math import asin, atan, atan2, cos, degrees, fabs, radians, sin, sqrt  # pow
 
 __all__ = _ALL_LAZY.formy
-__version__ = '24.05.24'
+__version__ = '24.05.28'
 
 _RADIANS2 = (PI / _180_0)**2  # degrees- to radians-squared
 _ratio_   = 'ratio'
@@ -232,8 +232,8 @@ def cosineAndoyerLambert_(phi2, phi1, lam21, datum=_WGS84):
        @raise TypeError: Invalid B{C{datum}}.
 
        @see: Functions L{cosineAndoyerLambert}, L{cosineForsytheAndoyerLambert_},
-             L{cosineLaw_}, L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{haversine_}, L{thomas_} and L{vincentys_} and U{Geodesy-PHP
+             L{cosineLaw_}, L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{haversine_}, L{thomas_} and L{vincentys_} and U{Geodesy-PHP
              <https://GitHub.com/jtejido/geodesy-php/blob/master/src/Geodesy/Distance/
              AndoyerLambert.php>}.
     '''
@@ -298,8 +298,8 @@ def cosineForsytheAndoyerLambert_(phi2, phi1, lam21, datum=_WGS84):
        @raise TypeError: Invalid B{C{datum}}.
 
        @see: Functions L{cosineForsytheAndoyerLambert}, L{cosineAndoyerLambert_},
-             L{cosineLaw_}, L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{haversine_}, L{thomas_} and L{vincentys_} and U{Geodesy-PHP
+             L{cosineLaw_}, L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{haversine_}, L{thomas_} and L{vincentys_} and U{Geodesy-PHP
              <https://GitHub.com/jtejido/geodesy-php/blob/master/src/Geodesy/
              Distance/ForsytheCorrection.php>}.
     '''
@@ -366,9 +366,9 @@ def cosineLaw_(phi2, phi1, lam21):
        @return: Angular distance (C{radians}).
 
        @see: Functions L{cosineLaw}, L{cosineAndoyerLambert_},
-             L{cosineForsytheAndoyerLambert_}, L{equirectangular_},
-             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
-             L{haversine_}, L{thomas_} and L{vincentys_}.
+             L{cosineForsytheAndoyerLambert_},  L{euclidean_},
+             L{flatLocal_}/L{hubeny_}, L{flatPolar_}, L{haversine_},
+             L{thomas_} and L{vincentys_}.
 
        @note: See note at function L{vincentys_}.
     '''
@@ -430,35 +430,31 @@ def equirectangular(lat1, lon1, lat2, lon2, radius=R_M, **adjust_limit_wrap):
        @arg lon1: Start longitude (C{degrees}).
        @arg lat2: End latitude (C{degrees}).
        @arg lon2: End longitude (C{degrees}).
-       @kwarg radius: Mean earth radius (C{meter}), datum (L{Datum})
-                      or ellipsoid (L{Ellipsoid}, L{Ellipsoid2} or
-                      L{a_f2Tuple}).
-       @kwarg adjust_limit_wrap: Optional keyword arguments for
-                     function L{equirectangular_}.
+       @kwarg radius: Mean earth radius (C{meter}), datum (L{Datum}) or ellipsoid
+                      (L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}).
+       @kwarg adjust_limit_wrap: Optional keyword arguments for function L{equirectangular4}.
 
-       @return: Distance (C{meter}, same units as B{C{radius}} or
-                the ellipsoid or datum axes).
+       @return: Distance (C{meter}, same units as B{C{radius}} or the ellipsoid or datum axes).
 
        @raise TypeError: Invalid B{C{radius}}.
 
-       @see: Function L{equirectangular_} for more details, the
-             available B{C{options}}, errors, restrictions and other,
-             approximate or accurate distance functions.
+       @see: Function L{equirectangular4} for more details, the available B{C{options}},
+             errors, restrictions and other, approximate or accurate distance functions.
     '''
-    d = sqrt(equirectangular_(Lat(lat1=lat1), Lon(lon1=lon1),
+    d = sqrt(equirectangular4(Lat(lat1=lat1), Lon(lon1=lon1),
                               Lat(lat2=lat2), Lon(lon2=lon2),
                             **adjust_limit_wrap).distance2)  # PYCHOK 4 vs 2-3
     return degrees2m(d, radius=_mean_radius(radius, lat1, lat2))
 
 
 def _equirectangular(lat1, lon1, lat2, lon2, **adjust_limit_wrap):
-    '''(INTERNAL) Helper for the L{frechet._FrecherMeterRadians}
+    '''(INTERNAL) Helper for the L{frechet._FrechetMeterRadians}
        and L{hausdorff._HausdorffMeterRedians} classes.
     '''
-    return equirectangular_(lat1, lon1, lat2, lon2, **adjust_limit_wrap).distance2 * _RADIANS2
+    return equirectangular4(lat1, lon1, lat2, lon2, **adjust_limit_wrap).distance2 * _RADIANS2
 
 
-def equirectangular_(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False):
+def equirectangular4(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False):
     '''Compute the distance between two points using the U{Equirectangular Approximation
        / Projection<https://www.Movable-Type.co.UK/scripts/latlong.html#equirectangular>}.
 
@@ -469,15 +465,15 @@ def equirectangular_(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False):
        @arg lon1: Start longitude (C{degrees}).
        @arg lat2: End latitude (C{degrees}).
        @arg lon2: End longitude (C{degrees}).
-       @kwarg adjust: Adjust the wrapped, unrolled longitudinal delta
-                      by the cosine of the mean latitude (C{bool}).
-       @kwarg limit: Optional limit for lat- and longitudinal deltas
-                     (C{degrees}) or C{None} or C{0} for unlimited.
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{lat2}}
-                    and B{C{lon2}} (C{bool}).
+       @kwarg adjust: Adjust the wrapped, unrolled longitudinal delta by the cosine
+                      of the mean latitude (C{bool}).
+       @kwarg limit: Optional limit for lat- and longitudinal deltas (C{degrees}) or
+                     C{None} or C{0} for unlimited.
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{lat2}} and
+                    B{C{lon2}} (C{bool}).
 
-       @return: A L{Distance4Tuple}C{(distance2, delta_lat, delta_lon,
-                unroll_lon2)} in C{degrees squared}.
+       @return: A L{Distance4Tuple}C{(distance2, delta_lat, delta_lon, unroll_lon2)}
+                in C{degrees squared}.
 
        @raise LimitError: If the lat- and/or longitudinal delta exceeds the
                           B{C{-limit..limit}} range and L{pygeodesy.limiterrors}
@@ -498,7 +494,7 @@ def equirectangular_(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False):
         d = max(fabs(d_lat), fabs(d_lon))
         if d > limit:
             t = _SPACE_(_delta_, Fmt.PAREN_g(d), Fmt.exceeds_limit(limit))
-            s =  unstr(equirectangular_, lat1, lon1, lat2, lon2,
+            s =  unstr(equirectangular4, lat1, lon1, lat2, lon2,
                                          limit=limit, wrap=wrap)
             raise LimitError(s, txt=t)
 
@@ -551,9 +547,9 @@ def euclidean_(phi2, phi1, lam21, adjust=True):
        @return: Angular distance (C{radians}).
 
        @see: Functions L{euclid}, L{euclidean}, L{cosineAndoyerLambert_},
-             L{cosineForsytheAndoyerLambert_}, L{cosineLaw_}, L{equirectangular_},
-             L{flatLocal_}/L{hubeny_}, L{flatPolar_}, L{haversine_}, L{thomas_}
-             and L{vincentys_}.
+             L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
+             L{flatLocal_}/L{hubeny_}, L{flatPolar_}, L{haversine_},
+             L{thomas_} and L{vincentys_}.
     '''
     if adjust:
         lam21 *= _scale_rad(phi2, phi1)
@@ -866,8 +862,8 @@ def flatLocal_(phi2, phi1, lam21, datum=_WGS84, scaled=True):
 
        @see: Functions L{flatLocal} or L{hubeny}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_}, L{flatPolar_},
-             L{equirectangular_}, L{euclidean_}, L{haversine_}, L{thomas_}
-             and L{vincentys_} and U{local, flat earth approximation
+             L{euclidean_}, L{haversine_}, L{thomas_} and L{vincentys_} and
+             U{local, flat earth approximation
              <https://www.EdWilliams.org/avform.htm#flat>}.
     '''
     E = _ellipsoidal(datum, flatLocal_)
@@ -920,8 +916,8 @@ def flatPolar_(phi2, phi1, lam21):
 
        @see: Functions L{flatPolar}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
-             L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{haversine_}, L{thomas_} and L{vincentys_}.
+             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{haversine_},
+             L{thomas_} and L{vincentys_}.
     '''
     a = fabs(PI_2 - phi1)  # co-latitude
     b = fabs(PI_2 - phi2)  # co-latitude
@@ -964,9 +960,9 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
        @kwarg earth: The earth model (L{Datum}, L{Ellipsoid}, L{Ellipsoid2},
                      L{a_f2Tuple} or a C{scalar} earth radius in C{meter}).
        @kwarg name_LatLon_and_kwds: Optional, overriding C{B{name}="hartzell"}
-                   (C{str}), C{B{LatLon}=None} class to return the intersection
+                   (C{str}), class C{B{LatLon}=None} to return the intersection
                    plus additional C{LatLon} keyword arguments, include the
-                   B{C{datum}} if different from B{C{earth}}.
+                   B{C{datum}} if different and to convert from B{C{earth}}.
 
        @return: The intersection (L{Vector3d}, B{C{pov}}'s C{cartesian type} or the
                 given B{C{LatLon}} instance) with attribute C{heigth} set to the
@@ -981,15 +977,14 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
        @see: Class L{Los}, functions L{tyr3d} and L{hartzell4} and methods
              L{Ellipsoid.hartzell4} and any C{Cartesian.hartzell} and C{LatLon.hartzell}.
     '''
-    D = _spherical_datum(earth, name__=hartzell)
     n, LatLon_and_kwds = _name2__(name_LatLon_and_kwds, name__=hartzell)
     try:
+        D = _spherical_datum(earth, name__=hartzell)
         r, h, i = _MODS.triaxials._hartzell3(pov, los, D.ellipsoid._triaxial)
-        r = _xnamed(r, n)
 
         C = _MODS.cartesianBase.CartesianBase
         if LatLon_and_kwds:
-            c = C(r, datum=D, name=r.name)
+            c = C(r, datum=D)
             r = c.toLatLon(**_xkwds(LatLon_and_kwds, height=h))
         elif isinstance(r, C):
             r.height = h
@@ -998,7 +993,7 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
     except Exception as x:
         raise IntersectionError(pov=pov, los=los, earth=earth, cause=x,
                                                 **LatLon_and_kwds)
-    return r
+    return _xnamed(r, n) if n else r
 
 
 def haversine(lat1, lon1, lat2, lon2, radius=R_M, wrap=False):
@@ -1045,8 +1040,8 @@ def haversine_(phi2, phi1, lam21):
 
        @see: Functions L{haversine}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
-             L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{thomas_} and L{vincentys_}.
+             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{thomas_} and L{vincentys_}.
 
        @note: See note at function L{vincentys_}.
     '''
@@ -1111,8 +1106,8 @@ def heightOrthometric(h_ll, N):
 
 
 def horizon(height, radius=R_M, refraction=False):
-    '''Determine the distance to the horizon from a given altitude
-       above the (spherical) earth.
+    '''Determine the distance to the horizon from a given altitude above the
+       (spherical) earth.
 
        @arg height: Altitude (C{meter} or same units as B{C{radius}}).
        @kwarg radius: Optional mean earth radius (C{meter}).
@@ -1560,27 +1555,18 @@ def philam2n_xyz(phi, lam, **name):
     return _2n_xyz(name, *sincos2_(phi, lam))
 
 
-def _Propy(inst, nargs, **_prop_func):
+def _Propy(func, nargs, kwds):
     '''(INTERNAL) Helper for the C{frechet.[-]Frechet**} and
        C{hausdorff.[-]Hausdorff*} classes.
     '''
-    _prop, func = _prop_func.popitem()  # _xkwds_item2(_func_func)
-    if func is None:  # getter
-        try:
-            return inst.__dict__[_prop]
-        except KeyError:
-            inst._notOverloaded(**inst.kwds)
-    else:  # setter
-        try:
-            if not callable(func):
-                raise TypeError(_not_(callable.__name__))
-            args = (0,) * nargs
-            _ = func(*args, **inst.kwds)
-        except Exception as x:
-            t = unstr(func, **inst.kwds)
-            raise _TypeError(t, cause=x)
-        inst.__dict__[_prop] = func
-#       return func
+    try:
+        _xcallable(distance=func)
+        # assert _args_kwds_count2(func)[0] == nargs + int(ismethod(func))
+        _ = func(*_0_0s(nargs), **kwds)
+    except Exception as x:
+        t = unstr(func, **kwds)
+        raise _TypeError(t, cause=x)
+    return func
 
 
 def _radical2(d, r1, r2, **name):  # in .ellipsoidalBaseDI, .sphericalTrigonometry, .vector3d
@@ -1723,8 +1709,8 @@ def thomas_(phi2, phi1, lam21, datum=_WGS84):
 
        @see: Functions L{thomas}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
-             L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{haversine_} and L{vincentys_} and U{Geodesy-PHP
+             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{haversine_} and L{vincentys_} and U{Geodesy-PHP
              <https://GitHub.com/jtejido/geodesy-php/blob/master/src/Geodesy/
              Distance/ThomasFormula.php>}.
     '''
@@ -1806,8 +1792,8 @@ def vincentys_(phi2, phi1, lam21):
 
        @see: Functions L{vincentys}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
-             L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{haversine_} and L{thomas_}.
+             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{haversine_} and L{thomas_}.
 
        @note: Functions L{vincentys_}, L{haversine_} and L{cosineLaw_}
               produce equivalent results, but L{vincentys_} is suitable

pygeodesy/frechet.py

@@ -94,7 +94,7 @@ from pygeodesy.named import _name2__, _Named, _NamedTuple, _Pass
 # from pygeodesy.namedTuples import PhiLam2Tuple  # from .points
 from pygeodesy.points import _distanceTo, _fractional,  isscalar, \
                               PhiLam2Tuple, points2 as _points2, radians
-from pygeodesy.props import property_doc_, property_RO
+from pygeodesy.props import Property, property_doc_, property_RO
 from pygeodesy.units import FIx, Float, Number_, _xUnit, _xUnits
 from pygeodesy.unitsBase import _Str_degrees, _Str_meter, _Str_NN, \
                                 _Str_radians, _Str_radians2
@@ -103,7 +103,7 @@ from collections import defaultdict as _defaultdict
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.frechet
-__version__ = '24.05.24'
+__version__ = '24.06.10'
 
 
 def _fraction(fraction, n):
@@ -252,14 +252,14 @@ class Frechet(_Named):
 #       '''(INTERNAL) I{Must be overloaded}.'''
 #       self._notOverloaded(*args, **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)
 
     @property_RO
     def kwds(self):
@@ -382,14 +382,14 @@ class _FrechetMeterRadians(Frechet):
         '''
         return self._discrete(point2s, fraction, _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 FrechetCosineAndoyerLambert(_FrechetMeterRadians):
@@ -507,7 +507,7 @@ class FrechetEquirectangular(Frechet):
 
            @kwarg fraction_name__adjust_limit_wrap: Optional C{B{fraction}=None}
                                  and C{B{name}=NN} and keyword arguments for
-                                 function L{pygeodesy.equirectangular_} I{with
+                                 function L{pygeodesy.equirectangular} I{with
                                  default} C{B{limit}=0} for I{backward compatibility}.
 
            @see: L{Frechet.__init__} for details about B{C{point1s}}, B{C{fraction}},
@@ -842,12 +842,11 @@ class Frechet6Tuple(_NamedTuple):
     _Names_ = ('fd',  'fi1', 'fi2', 'r',     _n_,      _units_)
     _Units_ = (_Pass,  FIx,   FIx,   Number_, Number_, _Pass)
 
-    def toUnits(self, **Error):  # PYCHOK expected
+    def toUnits(self, **Error_name):  # PYCHOK expected
         '''Overloaded C{_NamedTuple.toUnits} for C{fd} units.
         '''
         U = _xUnit(self.units, Float)  # PYCHOK expected
-        self._Units_ = (U,) + Frechet6Tuple._Units_[1:]
-        return _NamedTuple.toUnits(self, **Error)
+        return _NamedTuple.toUnits(self.reUnit(U), **Error_name)  # PYCHOK self
 
 #   def __gt__(self, other):
 #       _xinstanceof(Frechet6Tuple, other=other)