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

pygeodesy/ellipsoidalBase.py

@@ -37,7 +37,7 @@ from pygeodesy.units import Epoch, _isDegrees, Radius_, _1mm as _TOL_M
 # from math import fabs  # from .latlonBase
 
 __all__ = _ALL_LAZY.ellipsoidalBase
-__version__ = '24.05.21'
+__version__ = '24.05.31'
 
 
 class CartesianEllipsoidalBase(CartesianBase):
@@ -741,21 +741,19 @@ class LatLonEllipsoidalBase(LatLonBase):
         '''Parse a string consisting of C{"lat, lon[, height]"},
            representing a similar, ellipsoidal C{LatLon} point.
 
-           @arg strllh: Lat, lon and optional height (C{str}),
-                        see function L{pygeodesy.parse3llh}.
-           @kwarg height: Optional, default height (C{meter} or
-                          C{None}).
-           @kwarg datum: Optional datum (L{Datum}), overriding this
-                         datum I{without conversion}.
-           @kwarg epoch: Optional datum (L{Epoch}), overriding this
-                         epoch I{without conversion}.
-           @kwarg reframe: Optional datum (L{RefFrame}), overriding
-                           this reframe I{without conversion}.
+           @arg strllh: Lat, lon and optional height (C{str}), see function
+                        L{pygeodesy.parse3llh}.
+           @kwarg height: Optional, default height (C{meter} or C{None}).
+           @kwarg datum: Optional datum (L{Datum}), overriding this datum
+                         I{without conversion}.
+           @kwarg epoch: Optional datum (L{Epoch}), overriding this epoch
+                         I{without conversion}.
+           @kwarg reframe: Optional datum (L{RefFrame}), overriding this
+                           reframe I{without conversion}.
            @kwarg sep: Optional separator (C{str}).
-           @kwarg wrap: If C{True}, wrap or I{normalize} the lat-
-                        and longitude (C{bool}).
-           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding
-                        this name.
+           @kwarg wrap: If C{True}, wrap or I{normalize} the lat- and
+                        longitude (C{bool}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The similar point (ellipsoidal C{LatLon}).
 
@@ -914,7 +912,8 @@ class LatLonEllipsoidalBase(LatLonBase):
            @see: Function L{pygeodesy.toOsgr}.
         '''
         if toOsgr_kwds:
-            r = _MODS.osgr.toOsgr(self, kTM=kTM, **_xkwds(toOsgr_kwds, name=self.name))
+            kwds = _name1__(toOsgr_kwds, _or_nameof=self)
+            r = _MODS.osgr.toOsgr(self, kTM=kTM, **kwds)
         else:
             r =  self._osgrTM if kTM else self._osgr
         return r

pygeodesy/ellipsoidalGeodSolve.py

@@ -24,7 +24,7 @@ from pygeodesy.points import _areaError, ispolar  # PYCHOK exported
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalGeodSolve
-__version__ = '24.02.21'
+__version__ = '24.05.25'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -76,7 +76,7 @@ class LatLon(LatLonEllipsoidalBaseDI):
            @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}}
                   and other keyword arguments, ignored if C{B{Cartesian} is None}.
                   Use C{B{Cartesian}=...} to override this L{Cartesian} class
-                  or set C{B{Cartesian} is None}.
+                  or set C{B{Cartesian}=None}.
 
            @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if
                     B{C{Cartesian}} is C{None}, an L{Ecef9Tuple}C{(x, y, z,

pygeodesy/ellipsoidalKarney.py

@@ -43,7 +43,7 @@ from pygeodesy.props import deprecated_method, Property_RO
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalKarney
-__version__ = '24.02.21'
+__version__ = '24.05.25'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -105,8 +105,8 @@ class LatLon(LatLonEllipsoidalBaseDI):
 
            @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}}
                   and other keyword arguments, ignored if C{B{Cartesian} is None}.
-                  Use C{B{Cartesian}=...} to override this L{Cartesian} class
-                  or set C{B{Cartesian} is None}.
+                  Use C{B{Cartesian}=...} to override this L{Cartesian} class or
+                  set C{B{Cartesian}=None}.
 
            @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if
                     B{C{Cartesian}} is C{None}, an L{Ecef9Tuple}C{(x, y, z,

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.05.29'
 
 _argument_   = 'argument'
 _box_        = 'box'
@@ -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)