pygeodesy 24.10.10__py2.py3-none-any.whl → 24.11.11__py2.py3-none-any.whl

pygeodesy/lcc.py

@@ -48,7 +48,7 @@ from pygeodesy.utily import atan1, degrees90, degrees180, sincos2, tanPI_2_2
 from math import atan, fabs, log, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.lcc
-__version__ = '24.06.24'
+__version__ = '24.11.06'
 
 _E0_   = 'E0'
 _N0_   = 'N0'
@@ -620,9 +620,9 @@ def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc,
        @kwarg height: Optional height for the point, overriding the
                       default height (C{meter}).
        @kwarg Lcc: Class to return the I{Lambert} location (L{Lcc}).
-       @kwarg name_Lcc_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                   additional B{C{Lcc}} keyword arguments, ignored if
-                   B{C{Lcc} is None}.
+       @kwarg name_Lcc_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                   additional B{C{Lcc}} keyword arguments, ignored if B{C{Lcc}
+                   is None}.
 
        @return: The I{Lambert} location (L{Lcc}) or if C{B{Lcc} is None},
                 an L{EasNor3Tuple}C{(easting, northing, height)}.

pygeodesy/ltp.py

@@ -44,7 +44,7 @@ from pygeodesy.vector3d import _ALL_LAZY, Vector3d
 # from math import fabs, floor as _floor  # from .fmath, .fsums
 
 __all__ = _ALL_LAZY.ltp
-__version__ = '24.08.18'
+__version__ = '24.11.06'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -150,9 +150,9 @@ class Attitude(_NamedBase):
            @kwarg z: Z component of vector (C{scalar}), same units as B{C{x}}.
            @kwarg Vector: Class to return transformed point (C{Cartesian}, L{Vector3d}
                           or C{Vector3Tuple}) or C{None}.
-           @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{Vector}} keyword arguments, ignored if
-                       C{B{Vector} is None}.
+           @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{Vector}} keyword arguments, ignored if C{B{Vector}
+                       is None}.
 
            @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                     a named L{Vector3Tuple}C{(x, y, z)}.
@@ -469,9 +469,9 @@ class LocalCartesian(_NamedBase):
 
            @arg ecef: Geocentric (and geodetic) (L{Ecef9Tuple}).
            @arg Xyz: An L{XyzLocal}, L{Enu} or L{Ned} I{class} or C{None}.
-           @arg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                     additional B{C{Xyz}} keyword arguments, ignored if
-                     C{B{Xyz} is None}.
+           @arg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                     additional B{C{Xyz}} keyword arguments, ignored if C{B{Xyz}
+                     is None}.
 
            @return: An C{B{Xyz}(x, y, z, ltp, **B{name_Xyz_kwds}} instance or
                     if C{B{Xyz} is None}, a L{Local9Tuple}C{(x, y, z, lat, lon,
@@ -1098,9 +1098,9 @@ def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
                     (clockwise rotation along and around the y-axis).
        @kwarg Vector: Class to return the direction vector (C{Cartesian},
                       L{Vector3d} or C{Vector3Tuple}) or C{None}.
-       @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                   additional B{C{Vector}} keyword arguments, ignored if
-                   C{B{Vector} is None}.
+       @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                   additional B{C{Vector}} keyword arguments, ignored if C{B{Vector}
+                   is None}.
 
        @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                 a named L{Vector3Tuple}C{(x, y, z)}.

pygeodesy/ltpTuples.py

@@ -16,7 +16,7 @@ from pygeodesy.constants import _0_0, _1_0, _90_0, _N_90_0
 # from pygeodesy.dms import F_D, toDMS  # _MODS
 from pygeodesy.errors import _TypeError, _TypesError, _xattr, _xkwds, \
                              _xkwds_item2
-from pygeodesy.fmath import hypot, hypot_
+from pygeodesy.fmath import fdot_, hypot, hypot_
 from pygeodesy.interns import NN, _4_, _azimuth_, _center_, _COMMASPACE_, \
                              _ecef_, _elevation_, _height_, _lat_, _lon_, \
                              _ltp_, _M_, _name_, _up_, _X_, _x_, _xyz_, \
@@ -36,7 +36,7 @@ from pygeodesy.vector3d import Vector3d
 # from math import cos, radians  # from .utily
 
 __all__ = _ALL_LAZY.ltpTuples
-__version__ = '24.08.18'
+__version__ = '24.11.07'
 
 _aer_        = 'aer'
 _alt_        = 'alt'
@@ -126,9 +126,9 @@ class _AbcBase(_NamedBase):
         '''Get the I{local} I{Azimuth, Elevation, slant Range} (AER) components.
 
            @kwarg Aer: Class to return AER (L{Aer}) or C{None}.
-           @kwarg name_Aer_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{L{Aer}} keyword arguments, ignored if
-                       C{B{Aer} is None}.
+           @kwarg name_Aer_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{L{Aer}} keyword arguments, ignored if C{B{Aer}
+                       is None}.
 
            @return: AER as an L{Aer} instance or if C{B{Aer} is None}, an
                     L{Aer4Tuple}C{(azimuth, elevation, slantrange, ltp)}.
@@ -141,9 +141,9 @@ class _AbcBase(_NamedBase):
         '''Get the I{local} I{East, North, Up} (ENU) components.
 
            @kwarg Enu: Class to return ENU (L{Enu}) or C{None}.
-           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{L{Enu}} keyword arguments, ignored if
-                       C{B{Enu} is None}.
+           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{L{Enu}} keyword arguments, ignored if C{B{Enu}
+                       is None}.
 
            @return: ENU as an L{Enu} instance or if C{B{Enu} is None}, an
                     L{Enu4Tuple}C{(east, north, up, ltp)}.
@@ -156,9 +156,9 @@ class _AbcBase(_NamedBase):
         '''Get the I{local} I{North, East, Down} (NED) components.
 
            @kwarg Ned: Class to return NED (L{Ned}) or C{None}.
-           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{L{Ned}} keyword arguments, ignored if
-                       C{B{Ned} is None}.
+           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{L{Ned}} keyword arguments, ignored if C{B{Ned}
+                       is None}.
 
            @return: NED as an L{Ned} instance or if C{B{Ned} is None}, an
                     L{Ned4Tuple}C{(north, east, down, ltp)}.
@@ -172,9 +172,9 @@ class _AbcBase(_NamedBase):
 
            @kwarg Xyz: Class to return XYZ (L{XyzLocal}, L{Enu}, L{Ned}, L{Aer})
                        or C{None}.
-           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{Xyz}} keyword arguments, ignored if
-                       C{B{Xyz} is None}.
+           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{Xyz}} keyword arguments, ignored if C{B{Xyz}
+                       is None}.
 
            @return: XYZ as an B{C{Xyz}} instance or if C{B{Xyz} is None}, an
                     L{Xyz4Tuple}C{(x, y, z, ltp)}.
@@ -814,9 +814,9 @@ class XyzLocal(_Vector3d):
         '''Get the local I{Azimuth, Elevation, slant Range} components.
 
            @kwarg Aer: Class to return AER (L{Aer}) or C{None}.
-           @kwarg name_Aer_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{C{Aer}} keyword arguments,
-                       ignored if C{B{Aer} is None}.
+           @kwarg name_Aer_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{Aer}} keyword arguments, ignored if C{B{Aer}
+                       is None}.
 
            @return: AER as an L{Aer} instance or if C{B{Aer} is None}, an
                     L{Aer4Tuple}C{(azimuth, elevation, slantrange, ltp)}.
@@ -832,11 +832,11 @@ class XyzLocal(_Vector3d):
                              or C{None}.
            @kwarg ltp: Optional I{local tangent plane} (LTP) (L{Ltp}), overriding
                        this C{ltp}.
-           @kwarg name_Cartesian_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+           @kwarg name_Cartesian_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
                        additional B{C{Cartesian}} keyword arguments, ignored if
                        C{B{Cartesian} is None}.
 
-           @return: A B{C{Cartesian}} instance of if C{B{Cartesian} is None}, an
+           @return: A B{C{Cartesian}} instance or if C{B{Cartesian} is None}, an
                     L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
                     C{M=None}, always.
 
@@ -856,9 +856,9 @@ class XyzLocal(_Vector3d):
         '''Get the local I{East, North, Up} (ENU) components.
 
            @kwarg Enu: Class to return ENU (L{Enu}) or C{None}.
-           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{Enu}} keyword arguments, ignored if
-                       C{B{Enu} is None}.
+           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{Enu}} keyword arguments, ignored if C{B{Enu}
+                       is None}.
 
            @return: ENU as an L{Enu} instance or if C{B{Enu} is None}, an
                     L{Enu4Tuple}C{(east, north, up, ltp)}.
@@ -874,11 +874,11 @@ class XyzLocal(_Vector3d):
                           C{None}.
            @kwarg ltp: Optional I{local tangent plane} (LTP) (L{Ltp}), overriding
                        this ENU/NED/AER/XYZ's LTP.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{LatLon}} keyword arguments, ignored if
-                       C{B{LatLon} is None}.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{LatLon}} keyword arguments, ignored if C{B{LatLon}
+                       is None}.
 
-           @return: An B{C{LatLon}} instance of if C{B{LatLon} is None}, an
+           @return: An B{C{LatLon}} instance or if C{B{LatLon} is None}, an
                     L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
                     C{M=None}, always.
 
@@ -913,9 +913,9 @@ class XyzLocal(_Vector3d):
         '''Get the local I{North, East, Down} (Ned) components.
 
            @kwarg Ned: Class to return NED (L{Ned}) or C{None}.
-           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{Ned}} keyword arguments, ignored if
-                       C{B{Ned} is None}.
+           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{Ned}} keyword arguments, ignored if C{B{Ned}
+                       is None}.
 
            @return: NED as an L{Ned} instance or if C{B{Ned} is None}, an
                     L{Ned4Tuple}C{(north, east, down, ltp)}.
@@ -929,9 +929,9 @@ class XyzLocal(_Vector3d):
 
            @kwarg Xyz: Class to return XYZ (L{XyzLocal}, L{Enu}, L{Ned}, L{Aer})
                        or C{None}.
-           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{Xyz}} keyword arguments, ignored if
-                       C{B{Xyz} is None}.
+           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{Xyz}} keyword arguments, ignored if C{B{Xyz}
+                       is None}.
 
            @return: XYZ as an B{C{Xyz}} instance or if C{B{Xyz} is None}, an
                     L{Xyz4Tuple}C{(x, y, z, ltp)}.
@@ -1042,9 +1042,9 @@ class Enu(XyzLocal):
            @arg location: The geodetic (C{LatLon}) or geocentric (C{Cartesian},
                           L{Vector3d}) location, like a Point-Of-View.
            @kwarg Uvw: Class to return UWV (L{Uvw}) or C{None}.
-           @kwarg name_Uvw_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{L{Uvw}} keyword arguments, ignored if
-                       C{B{Uvw} is None}.
+           @kwarg name_Uvw_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{L{Uvw}} keyword arguments, ignored if C{B{Uvw}
+                       is None}.
 
            @return: UVW as a L{Uvw} instance or if C{B{Uvw} is None}, a
                     L{Uvw3Tuple}C{(u, v, w)}.
@@ -1059,10 +1059,10 @@ class Enu(XyzLocal):
             raise _TypeError(location=location, cause=x)
         e, n, u, _ = self.enu4
 
-        t = ca * u - sa * n
-        U = cb * t - sb * e
-        V = cb * e + sb * t
-        W = ca * n + sa * u
+        t = fdot_(ca, u, -sa, n)
+        U = fdot_(cb, t, -sb, e)
+        V = fdot_(cb, e,  sb, t)
+        W = fdot_(ca, n,  sa, u)
 
         n, kwds = _name2__(name_Uvw_kwds, _or_nameof=self)
         return Uvw3Tuple(U, V, W, name=n) if Uvw is None else \
@@ -1185,9 +1185,9 @@ class Local9Tuple(_NamedTuple):
         '''Get the I{local} I{Azimuth, Elevation, slant Range} (AER) components.
 
            @kwarg Aer: Class to return AER (L{Aer}) or C{None}.
-           @kwarg name_Aer_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{L{Aer}} keyword arguments, ignored if
-                       C{B{Aer} is None}.
+           @kwarg name_Aer_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{L{Aer}} keyword arguments, ignored if C{B{Aer}
+                       is None}.
 
            @return: AER as an L{Aer} instance or if C{B{Aer} is None}, an
                     L{Aer4Tuple}C{(azimuth, elevation, slantrange, ltp)}.
@@ -1201,7 +1201,7 @@ class Local9Tuple(_NamedTuple):
 
            @kwarg Cartesian: Optional class to return C{(x, y, z)} (C{Cartesian})
                              or C{None}.
-           @kwarg name_Cartesian_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+           @kwarg name_Cartesian_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
                        additional B{C{Cartesian}} keyword arguments, ignored if
                        C{B{Cartesian} is None}.
 
@@ -1216,9 +1216,9 @@ class Local9Tuple(_NamedTuple):
         '''Get the I{local} I{East, North, Up} (ENU) components.
 
            @kwarg Enu: Class to return ENU (L{Enu}) or C{None}.
-           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{L{Enu}} keyword arguments, ignored if
-                       C{B{Enu} is None}.
+           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{L{Enu}} keyword arguments, ignored if C{B{Enu}
+                       is None}.
 
            @return: ENU as an L{Enu} instance or if C{B{Enu} is None}, an
                     L{Enu4Tuple}C{(east, north, up, ltp)}.
@@ -1232,14 +1232,14 @@ class Local9Tuple(_NamedTuple):
 
            @kwarg LatLon: Optional class to return C{(lat, lon, height)}
                           (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{LatLon}} keyword arguments, ignored if
-                       C{B{LatLon} is None}.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{LatLon}} keyword arguments, ignored if C{B{LatLon}
+                       is None}.
 
-           @return: An instance of C{B{LatLon}(lat, lon, **B{LatLon_kwds})}
-                    or if C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
-                    height)} respectively L{LatLon4Tuple}C{(lat, lon, height,
-                    datum)} depending on whether C{datum} is un-/specified.
+           @return: An instance of C{B{LatLon}(lat, lon, **B{LatLon_kwds})} or if
+                    C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon, height)}
+                    respectively L{LatLon4Tuple}C{(lat, lon, height, datum)}
+                    depending on whether C{datum} is un-/specified.
 
            @raise TypeError: Invalid B{C{LatLon}} or B{C{name_LatLon_kwds}}.
         '''
@@ -1249,9 +1249,9 @@ class Local9Tuple(_NamedTuple):
         '''Get the I{local} I{North, East, Down} (NED) components.
 
            @kwarg Ned: Class to return NED (L{Ned}) or C{None}.
-           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{L{Ned}} keyword arguments, ignored if
-                       C{B{Ned} is None}.
+           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{L{Ned}} keyword arguments, ignored if C{B{Ned}
+                       is None}.
 
            @return: NED as an L{Ned} instance or if C{B{Ned} is None}, an
                     L{Ned4Tuple}C{(north, east, down, ltp)}.
@@ -1264,9 +1264,9 @@ class Local9Tuple(_NamedTuple):
         '''Get the I{local} I{X, Y, Z} (XYZ) components.
 
            @kwarg Xyz: Class to return XYZ (L{XyzLocal}) or C{None}.
-           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{Xyz}} keyword arguments, ignored if
-                       C{B{Xyz} is None}.
+           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{Xyz}} keyword arguments, ignored if C{B{Xyz}
+                       is None}.
 
            @return: XYZ as an B{C{Xyz}} instance or if C{B{Xyz} is None},
                     an L{Xyz4Tuple}C{(x, y, z, ltp)}.
@@ -1324,9 +1324,9 @@ class Uvw(_Vector3d):
            @arg location: The geodetic (C{LatLon}) or geocentric (C{Cartesian},
                           L{Vector3d}) location from where to cast the L{Los}.
            @kwarg Enu: Class to return ENU (L{Enu}) or C{None}.
-           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{L{Enu}} keyword arguments, ignored if
-                       C{B{Enu} is None}.
+           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{L{Enu}} keyword arguments, ignored if C{B{Enu}
+                       is None}.
 
            @return: ENU as an L{Enu} instance or if C{B{Enu} is None}, an
                     L{Enu4Tuple}C{(east, north, up, ltp)} with C{ltp=None}.
@@ -1341,10 +1341,10 @@ class Uvw(_Vector3d):
             raise _TypeError(location=location, cause=x)
         u, v, w = self.uvw
 
-        t = cb * u + sb * v
-        E = cb * v - sb * u
-        N = ca * w - sa * t
-        U = ca * t + sa * w
+        t = fdot_(cb, u,  sb, v)
+        E = fdot_(cb, v, -sb, u)
+        N = fdot_(ca, w, -sa, t)
+        U = fdot_(ca, t,  sa, w)
 
         n, kwds = _name2__(name_Enu_kwds, _or_nameof=self)
         return Enu4Tuple(E, N, U, name=n) if Enu is None else \
@@ -1570,15 +1570,14 @@ class Footprint5Tuple(_NamedTuple):
            @kwarg ltp: The I{local tangent plane} (L{Ltp}), overriding this
                        footprint's C{center} or C{frustrum} C{ltp}.
            @kwarg LatLon: Optional I{geodetic} class (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{LatLon}} keyword arguments, ignored if
-                       C{B{LatLon} is None}.
-
-           @return: A L{Footprint5Tuple} of 5 C{B{LatLon}(lat, lon,
-                    **B{name_LatLon_kwds})} instances or if C{B{LatLon} is None},
-                    5 L{LatLon3Tuple}C{(lat, lon, height)}s respectively
-                    5 L{LatLon4Tuple}C{(lat, lon, height, datum)}s depending
-                    on whether keyword argument C{datum} is un-/specified.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{LatLon}} keyword arguments, ignored if C{B{LatLon}
+                       is None}.
+
+           @return: A L{Footprint5Tuple} of 5 C{B{LatLon}(lat, lon, **B{name_LatLon_kwds})}
+                    instances or if C{B{LatLon} is None}, 5 L{LatLon3Tuple}C{(lat, lon,
+                    height)}s respectively 5 L{LatLon4Tuple}C{(lat, lon, height, datum)}s
+                    depending on whether keyword argument C{datum} is un-/specified.
 
            @raise TypeError: Invalid B{C{ltp}}, B{C{LatLon}} or B{C{name_LatLon_kwds}}.
 

pygeodesy/mgrs.py

@@ -55,7 +55,7 @@ from pygeodesy.utm import toUtm8, _to3zBlat, Utm, _UTM_ZONE_MAX, _UTM_ZONE_MIN
 # from pygeodesy.utmupsBase import _UTM_ZONE_MAX, _UTM_ZONE_MIN  # from .utm
 
 __all__ = _ALL_LAZY.mgrs
-__version__ = '24.09.04'
+__version__ = '24.11.06'
 
 _AN_    = 'AN'  # default south pole grid tile and band B
 _AtoPx_ = _AtoZnoIO_.tillP
@@ -594,15 +594,14 @@ def toMgrs(utmups, Mgrs=Mgrs, **name_Mgrs_kwds):
     '''Convert a UTM or UPS coordinate to an MGRS grid reference.
 
        @arg utmups: A UTM or UPS coordinate (L{Utm}, L{Etm} or L{Ups}).
-       @kwarg Mgrs: Optional class to return the MGRS grid reference
-                    (L{Mgrs}) or C{None}.
-       @kwarg name_Mgrs_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                   additional B{C{Mgrs}} keyword arguments, ignored if
-                   C{B{Mgrs} is None}.
+       @kwarg Mgrs: Optional class to return the MGRS grid reference (L{Mgrs})
+                    or C{None}.
+       @kwarg name_Mgrs_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                   additional B{C{Mgrs}} keyword arguments, ignored if C{B{Mgrs}
+                   is None}.
 
-       @return: The MGRS grid reference as B{C{Mgrs}} or if C{B{Mgrs} is
-                None} as an L{Mgrs6Tuple}C{(zone, EN, easting, northing,
-                band, datum)}.
+       @return: The MGRS grid reference as B{C{Mgrs}} or if C{B{Mgrs} is None} as
+                an L{Mgrs6Tuple}C{(zone, EN, easting, northing, band, datum)}.
 
        @raise MGRSError: Invalid B{C{utmups}}.
 
@@ -654,32 +653,32 @@ if __name__ == '__main__':
 
     def _main():
 
-        from pygeodesy.ellipsoidalVincenty import fabs, LatLon
+        from pygeodesy.ellipsoidalVincenty import LatLon,  fabs
         from pygeodesy.internals import _fper, printf
-        from pygeodesy.lazily import _getenv, _PYGEODESY_GEOCONVERT_
+        from pygeodesy.karney import _Xables
 
 #       from math import fabs  # from .ellipsoidalVincenty
-        from os import access as _access, linesep as _NL, X_OK as _X_OK
 
         # <https://GeographicLib.sourceforge.io/C++/doc/GeoConvert.1.html>
-        _GeoConvert = _getenv(_PYGEODESY_GEOCONVERT_, '/opt/local/bin/GeoConvert')
-        if _access(_GeoConvert, _X_OK):
-            GC_m = _GeoConvert, '-m'  # -m converts latlon to MGRS
-            printf(' using: %s ...', _SPACE_.join(GC_m))
-            from pygeodesy.solveBase import _popen2
+        G = _Xables.GeoConvert(_Xables.bin_)
+        if _Xables.X_OK(G):
+            from pygeodesy.internals import _popen2
+            printf(' using: %s', _Xables.name_version(G, base=False))
+            cmd = G, '-m'  # -m converts latlon to MGRS
         else:
-            GC_m = _popen2 = None
+            printf(' sorry: %s', _Xables.X_not(G))
+            cmd = _popen2 = None
 
         e = n = 0
         try:
             for lat in range(-90, 91, 1):
                 printf('%6s: lat %s ...', n, lat, end=NN, flush=True)
-                nl = _NL
+                nl = _MODS.os.linesep
                 for lon in range(-180, 181, 1):
                     m = LatLon(lat, lon).toMgrs()
-                    if _popen2:
+                    if _popen2:  # and cmd
                         t = '%s %s' % (lat, lon)
-                        g = _popen2(GC_m, stdin=t)[1]
+                        g = _popen2(cmd, stdin=t)[0]
                         t =  m.toStr()  # sep=NN
                         if t != g:
                             e += 1

pygeodesy/named.py

@@ -20,13 +20,14 @@ from pygeodesy.errors import _AssertionError, _AttributeError, _incompatible, \
                              _NotImplementedError, _TypeError, _TypesError, \
                              _UnexpectedError, UnitError, _ValueError, \
                              _xattr, _xkwds, _xkwds_item2, _xkwds_pop2
-from pygeodesy.internals import _caller3, _dunder_nameof, _isPyPy, _sizeof, _under
+from pygeodesy.internals import _caller3, _DUNDER_nameof, _getPYGEODESY, _isPyPy, \
+                                _sizeof, _under
 from pygeodesy.interns import MISSING, NN, _AT_, _COLON_, _COLONSPACE_, _COMMA_, \
                              _COMMASPACE_, _doesn_t_exist_, _DOT_, _DUNDER_, \
-                             _dunder_name_, _EQUAL_, _exists_, _immutable_, _name_, \
+                             _DUNDER_name_, _EQUAL_, _exists_, _immutable_, _name_, \
                              _NL_, _NN_, _no_, _other_, _s_, _SPACE_, _std_, \
                              _UNDER_, _vs_
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.props import _allPropertiesOf_n, deprecated_method, _hasProperty, \
                             _update_all, property_doc_, Property_RO, property_RO, \
                             _update_attrs
@@ -34,7 +35,7 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.09.02'
+__version__ = '24.10.14'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -45,7 +46,7 @@ _MRO_               = 'MRO'
 _name               = _under(_name_)
 _Names_             = '_Names_'
 _registered_        = 'registered'  # PYCHOK used!
-_std_NotImplemented = _getenv('PYGEODESY_NOTIMPLEMENTED', NN).lower() == _std_
+_std_NotImplemented = _getPYGEODESY('NOTIMPLEMENTED', NN).lower() == _std_
 _such_              = 'such'
 _Units_             = '_Units_'
 _UP                 =  2
@@ -140,6 +141,10 @@ class _Named(object):
     _classnaming = False  # prefixed (C{bool})
 #   _updates     = 0      # OBSOLETE Property/property updates
 
+    def __format__(self, fmt):  # PYCHOK no cover
+        '''Not implemented.'''
+        return _NotImplemented(self, fmt)
+
     def __imatmul__(self, other):  # PYCHOK no cover
         '''Not implemented.'''
         return _NotImplemented(self, other)  # PYCHOK Python 3.5+
@@ -614,7 +619,7 @@ class _NamedEnum(_NamedDict):
            @arg Classes: Additional, acceptable classes or C{type}s.
         '''
         self._item_Classes = (Class,) + Classes
-        n = _name__(**name) or NN(Class.__name__, _s_)  # _dunder_nameof
+        n = _name__(**name) or NN(Class.__name__, _s_)  # _DUNDER_nameof
         if n and _xvalid(n, underOK=True):
             _Named.name.fset(self, n)  # see _Named.name
 
@@ -1237,7 +1242,7 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
     try:
         n = clas.__name__
     except AttributeError:
-        n = clas if isstr(clas) else _dunder_name_
+        n = clas if isstr(clas) else _DUNDER_name_
     if prefixed or (classnaming() if prefixed is None else False):
         try:
             m =  clas.__module__.rsplit(_DOT_, 1)
@@ -1256,7 +1261,7 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
 #     if name:  # is given
 #         n = _name__(**name) if isinstance(name, dict) else str(name)
 #     elif name__ is not None:
-#         n = getattr(name__, _dunder_name_, NN)  # _xattr(name__, __name__=NN)
+#         n = getattr(name__, _DUNDER_name_, NN)  # _xattr(name__, __name__=NN)
 #     else:
 #         n = name  # NN or None or {} or any False type
 #     if _or_nameof is not None and not n:
@@ -1293,7 +1298,7 @@ def _name2__(name=NN, name__=None, _or_nameof=None, **kwds):
         else:
             n = str(name)
     elif name__ is not None:
-        n = _dunder_nameof(name__, NN)
+        n = _DUNDER_nameof(name__, NN)
     else:
         n = name if name is None else NN
     if _or_nameof is not None and not n:
@@ -1328,7 +1333,7 @@ def _notDecap(where):
 def _notError(inst, name, args, kwds):  # PYCHOK no cover
     '''(INTERNAL) Format an error message.
     '''
-    n = _DOT_(classname(inst, prefixed=True), _dunder_nameof(name, name))
+    n = _DOT_(classname(inst, prefixed=True), _DUNDER_nameof(name, name))
     m = _COMMASPACE_.join(modulename(c, prefixed=True) for c in inst.__class__.__mro__[1:-1])
     return _COMMASPACE_(unstr(n, *args, **kwds), Fmt.PAREN(_MRO_, m))
 

pygeodesy/nvectorBase.py

@@ -38,7 +38,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.07.12'
+__version__ = '24.10.12'
 
 
 class NvectorBase(Vector3d):  # XXX kept private

pygeodesy/osgr.py

@@ -53,7 +53,7 @@ from pygeodesy.utily import degrees90, degrees180, sincostan3, truncate
 from math import cos, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.osgr
-__version__ = '24.08.13'
+__version__ = '24.11.06'
 
 _equivalent_ = 'equivalent'
 _OSGR_       = 'OSGR'
@@ -505,20 +505,17 @@ def _ll2LatLon3(ll, LatLon, datum, LatLon_kwds):
 
 
 def parseOSGR(strOSGR, Osgr=Osgr, **name_Osgr_kwds):
-    '''Parse a string representing an OS Grid Reference, consisting
-       of C{"[GD] easting northing"}.
+    '''Parse a string representing an OS Grid Reference, consisting of C{"[GD]
+       easting northing"}.
 
-       Accepts standard OS Grid References like "SU 387 148", with
-       or without whitespace separators, from 2- up to 22-digit
-       references, or all-numeric, comma-separated references in
-       meters, for example "438700,114800".
+       Accepts standard OS Grid References like "SU 387 148", with or without
+       whitespace separators, from 2- up to 22-digit references, or all-numeric,
+       comma-separated references in meters, for example "438700,114800".
 
        @arg strOSGR: An OSGR coordinate (C{str}).
-       @kwarg Osgr: Optional class to return the OSGR coordinate
-                    (L{Osgr}) or C{None}.
-       @kwarg name_Osgr_kwds: Optional C{B{name}=NN} (C{str}) and
-                   optional, additional B{C{Osgr}} keyword arguments,
-                   ignored if C{B{Osgr} is None}.
+       @kwarg Osgr: Optional class to return the OSGR coordinate (L{Osgr}) or C{None}.
+       @kwarg name_Osgr_kwds: Optional C{B{name}=NN} (C{str}) and optionally, additional
+                   B{C{Osgr}} keyword arguments, ignored if C{B{Osgr} is None}.
 
        @return: An (B{C{Osgr}}) instance or if C{B{Osgr} is None}, an
                 L{EasNor2Tuple}C{(easting, northing)}.

pygeodesy/points.py

@@ -62,7 +62,7 @@ from pygeodesy.utily import atan2b, degrees90, degrees180, degrees2m, \
 from math import cos, fabs, fmod as _fmod, radians, sin
 
 __all__ = _ALL_LAZY.points
-__version__ = '24.09.23'
+__version__ = '24.10.24'
 
 _ilat_  = 'ilat'
 _ilon_  = 'ilon'
@@ -147,7 +147,7 @@ class LatLon_(LatLonBase):  # XXX in heights._HeightBase.height
            @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
                         the B{C{other}} point (C{bool}).
 
-           @return: Intermediate point (this C{LatLon}).
+           @return: Intermediate point (same C{LatLon} class).
 
            @raise TypeError: Incompatible B{C{other}} C{type}.
         '''