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

pygeodesy/cartesianBase.py

@@ -28,8 +28,8 @@ from pygeodesy.named import _name2__, _Pass
 from pygeodesy.namedTuples import LatLon4Tuple, _NamedTupleTo , Vector3Tuple, \
                                   Vector4Tuple,  Bearing2Tuple  # PYCHOK .sphericalBase
 # from pygeodesy.nvectorBase import _N_vector  # _MODS
-from pygeodesy.props import deprecated_method, Property, Property_RO, \
-                            property_doc_, property_RO, _update_all
+from pygeodesy.props import deprecated_method, Property, Property_RO, property_doc_, \
+                            property_RO, property_ROnce, _update_all
 # from pygeodesy,resections import cassini, collins5, pierlot, pierlotx, \
 #                                  tienstra7  # _MODS
 # from pygeodesy.streprs import Fmt  # from .fsums
@@ -43,7 +43,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 # from math import atan2, degrees, fabs, radians, sqrt  # from .fmath, .utily
 
 __all__ = _ALL_LAZY.cartesianBase
-__version__ = '24.06.11'
+__version__ = '24.07.29'
 
 _r_     = 'r'
 _theta_ = 'theta'
@@ -211,12 +211,11 @@ class CartesianBase(Vector3d):
             r = Cartesian(*c, **kwds)
         return r.renamed(n) if n else r
 
-    @property_RO
+    @property_ROnce
     def Ecef(self):
         '''Get the ECEF I{class} (L{EcefKarney}), I{once}.
         '''
-        CartesianBase.Ecef = E = _MODS.ecef.EcefKarney  # overwrite property_RO
-        return E
+        return _MODS.ecef.EcefKarney
 
     @Property_RO
     def _ecef9(self):
@@ -301,7 +300,7 @@ class CartesianBase(Vector3d):
                     coordinates I{at height} in C{meter}, conventionally.
 
            @note: This cartesian's coordinates are returned if B{C{earth}} and this
-                  datum or B{C{heigth}} and/or this height are C{None} or undefined.
+                  datum or B{C{height}} and/or this height are C{None} or undefined.
 
            @note: Include keyword argument C{B{datum}=None} if class B{C{Cartesian}}
                   does not accept a B{C{datum}} keyword agument.

pygeodesy/css.py

@@ -27,13 +27,13 @@ from pygeodesy.namedTuples import EasNor2Tuple, EasNor3Tuple, \
 from pygeodesy.props import deprecated_Property_RO, Property, \
                                        Property_RO, _update_all
 from pygeodesy.streprs import Fmt, _fstrENH2, _fstrLL0, _xzipairs
-from pygeodesy.units import Bearing, Degrees, Easting, Height, _heigHt, \
+from pygeodesy.units import Azimuth, Degrees, Easting, Height, _heigHt, \
                             Lat_, Lon_, Northing, Scalar
 
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.css
-__version__ = '24.06.11'
+__version__ = '24.07.25'
 
 
 def _CS0(cs0):
@@ -578,7 +578,7 @@ class EasNorAziRk4Tuple(_NamedTuple):
        C{reciprocal} of azimuthal northing scale, both in C{degrees}.
     '''
     _Names_ = (_easting_, _northing_, _azimuth_, _reciprocal_)
-    _Units_ = ( Easting,   Northing,   Bearing,   Scalar)
+    _Units_ = ( Easting,   Northing,   Azimuth,   Scalar)
 
 
 class EasNorAziRkEqu6Tuple(_NamedTuple):
@@ -589,7 +589,7 @@ class EasNorAziRkEqu6Tuple(_NamedTuple):
        C{equatorarc} and C{equatorazimuth}, all in C{degrees}.
     '''
     _Names_ = EasNorAziRk4Tuple._Names_ + ('equatorarc', 'equatorazimuth')
-    _Units_ = EasNorAziRk4Tuple._Units_ + ( Degrees,      Bearing)
+    _Units_ = EasNorAziRk4Tuple._Units_ + ( Degrees,      Azimuth)
 
 
 class LatLonAziRk4Tuple(_NamedTuple):
@@ -598,7 +598,7 @@ class LatLonAziRk4Tuple(_NamedTuple):
        C{reciprocal} the reciprocal of azimuthal northing scale.
     '''
     _Names_ = (_lat_, _lon_, _azimuth_, _reciprocal_)
-    _Units_ = ( Lat_,  Lon_,  Bearing,   Scalar)
+    _Units_ = ( Lat_,  Lon_,  Azimuth,   Scalar)
 
 
 def toCss(latlon, cs0=None, height=None, Css=Css, **name):

pygeodesy/ecef.py

@@ -76,7 +76,7 @@ from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name__, _name1__, _NamedBase, _NamedTuple, _Pass, _xnamed
 from pygeodesy.namedTuples import LatLon2Tuple, LatLon3Tuple, \
                                   PhiLam2Tuple, Vector3Tuple, Vector4Tuple
-from pygeodesy.props import deprecated_method, Property_RO, property_RO, property_doc_
+from pygeodesy.props import deprecated_method, Property_RO, property_ROver, property_doc_
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
 from pygeodesy.units import _isRadius, Degrees, Height, Int, Lam, Lat, Lon, Meter, \
                              Phi, Scalar, Scalar_
@@ -86,7 +86,7 @@ from pygeodesy.utily import atan1, atan1d, atan2d, degrees90, degrees180, \
 from math import atan2, cos, degrees, fabs, radians, sqrt
 
 __all__ = _ALL_LAZY.ecef
-__version__ = '24.06.11'
+__version__ = '24.06.12'
 
 _Ecef_    = 'Ecef'
 _prolate_ = 'prolate'
@@ -261,13 +261,12 @@ class _EcefBase(_NamedBase):
             raise EcefError(phi=phi, lam=lam, height=height, cause=x)
         return self._forward(*plhn, M=M, _philam=True)
 
-    @property_RO
+    @property_ROver
     def _Geocentrics(self):
         '''(INTERNAL) Get the valid geocentric classes. I{once}.
         '''
-        _EcefBase._Geocentrics = t = (Ecef9Tuple,    # overwrite property_RO
-                                     _MODS.cartesianBase.CartesianBase)
-        return t
+        return (Ecef9Tuple,  # overwrite property_ROver
+               _MODS.cartesianBase.CartesianBase)
 
     @Property_RO
     def _isYou(self):
@@ -1028,12 +1027,11 @@ class Ecef9Tuple(_NamedTuple):
     _Names_ = (_x_,   _y_,   _z_,   _lat_, _lon_, _height_, _C_,  _M_,   _datum_)
     _Units_ = ( Meter, Meter, Meter, Lat,   Lon,   Height,   Int, _Pass, _Pass)
 
-    @property_RO
+    @property_ROver
     def _CartesianBase(self):
         '''(INTERNAL) Get class C{CartesianBase}, I{once}.
         '''
-        Ecef9Tuple._CartesianBase = C = _MODS.cartesianBase.CartesianBase  # overwrite property_RO
-        return C
+        return _MODS.cartesianBase.CartesianBase  # overwrite property_ROver
 
     @deprecated_method
     def convertDatum(self, datum2):  # for backward compatibility

pygeodesy/ellipsoids.py

@@ -83,7 +83,7 @@ from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _NamedEnum, \
                                 _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
+                            deprecated_property_RO, property_RO, property_ROver
 from pygeodesy.streprs import Fmt, fstr, instr, strs, unstr
 # from pygeodesy.triaxials import _hartzell3  # _MODS
 from pygeodesy.units import Bearing_, Distance, Float, Float_, Height, Lamd, Lat, Meter, \
@@ -93,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.06.24'
+__version__ = '24.07.25'
 
 _f_0_0    = Float(f =_0_0)  # zero flattening
 _f__0_0   = Float(f_=_0_0)  # zero inverse flattening
@@ -1029,17 +1029,18 @@ class Ellipsoid(_NamedEnumItem):
                 raise _ValueError(exact=g, ellipsoid=E, txt_not_=self.name)
         return g
 
-    @property_RO
+    @property_ROver
     def _Geodesics(self):
         '''(INTERNAL) Get all C{Geodesic...} classes, I{once}.
         '''
+        t = (_MODS.geodesicx.GeodesicExact,
+             _MODS.geodsolve.GeodesicSolve)
         try:
-            t = _MODS.geodesicw._wrapped.Geodesic,
+            t += (_MODS.geodesicw.Geodesic,
+                  _MODS.geodesicw._wrapped.Geodesic)
         except ImportError:
-            t = ()
-        Ellipsoid._Geodesics = t = (_MODS.geodesicx.GeodesicExact,  # overwrite property_RO
-                                    _MODS.geodsolve.GeodesicSolve) + t
-        return t
+            pass
+        return t  # overwrite property_ROver
 
     @property_RO
     def geodesicw(self):
@@ -1517,14 +1518,13 @@ class Ellipsoid(_NamedEnumItem):
         #     raise _IsnotError(_ellipsoidal_, ellipsoid=self)
         return _MODS.rhumb.ekx.Rhumb(self, name=self.name)
 
-    @property_RO
+    @property_ROver
     def _Rhumbs(self):
         '''(INTERNAL) Get all C{Rhumb...} classes, I{once}.
         '''
         p = _MODS.rhumb
-        Ellipsoid._Rhumbs = t = (p.aux_.RhumbAux,  # overwrite property_RO
-                                 p.ekx.Rhumb, p.solve.RhumbSolve)
-        return t
+        return (p.aux_.RhumbAux,  # overwrite property_ROver
+                p.ekx.Rhumb, p.solve.RhumbSolve)
 
     @property
     def rhumbsolve(self):

pygeodesy/formy.py

@@ -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.06.15'
+__version__ = '24.07.29'
 
 _RADIANS2 = (PI / _180_0)**2  # degrees- to radians-squared
 _ratio_   = 'ratio'
@@ -962,7 +962,7 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
                    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
+                given B{C{LatLon}} instance) with attribute C{height} set to the
                 distance to the B{C{pov}}.
 
        @raise IntersectionError: Invalid B{C{pov}} or B{C{pov}} inside the earth or

pygeodesy/fsums.py

@@ -273,11 +273,17 @@ def _stresidual(prefix, residual, R=0, **mod_ratio):
 def _2sum(a, b):  # by .testFmath
     '''(INTERNAL) Return C{a + b} as 2-tuple (sum, residual).
     '''
+    # Neumaier, A. U{Rundungsfehleranalyse einiger Verfahren zur Summation endlicher
+    # Summen<https://OnlineLibrary.Wiley.com/doi/epdf/10.1002/zamm.19740540106>},
+    # 1974, Zeitschrift für Angewandte Mathmatik und Mechanik, vol 51, nr 1, p 39-51
+    # <https://StackOverflow.com/questions/78633770/can-neumaier-summation-be-sped-up>
     s = a + b
     if _isfinite(s):
         if fabs(a) < fabs(b):
-            b, a = a, b
-        return s, (b - (s - a))
+            r = (b - s) + a
+        else:
+            r = (a - s) + b
+        return s, r
     u = unstr(_2sum, a, b)
     t = Fmt.PARENSPACED(_not_finite_, s)
     raise _OverflowError(u, txt=t)
@@ -1909,10 +1915,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
 
            @raise ResidualError: Invalid B{C{threshold}}.
 
-           @note: L{ResidualError}s may be thrown if the non-zero I{ratio}
-                  C{residual / fsum} exceeds the given B{C{threshold}} and
-                  if the C{residual} is non-zero and I{significant} vs the
-                  C{fsum}, i.e. C{(fsum + residual) != fsum} and if optional
+           @note: L{ResidualError}s may be thrown if (1) the non-zero I{ratio}
+                  C{residual / fsum} exceeds the given B{C{threshold}} and (2)
+                  the C{residual} is non-zero and (3) I{significant} vs the
+                  C{fsum}, i.e. C{(fsum + residual) != fsum} and (4) optional
                   keyword argument C{raiser=False} is missing.  Specify a
                   negative B{C{threshold}} for only non-zero C{residual}
                   testing without I{significant}.

pygeodesy/gars.py

@@ -3,33 +3,33 @@
 
 u'''I{Global Area Reference System} (GARS) en-/decoding.
 
-Classes L{Garef} and L{GARSError} and several functions to encode,
-decode and inspect I{Global Area Reference System} (GARS) references.
-
-Transcoded from C++ class U{GARS
-<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GARS.html>}
-by I{Charles Karney}.  See also U{Global Area Reference System
-<https://WikiPedia.org/wiki/Global_Area_Reference_System>} and U{NGA (GARS)
-<https://Earth-Info.NGA.mil/GandG/coordsys/grids/gars.html>}.
+Class L{Garef} and several functions to encode, decode and inspect
+GARS references.
+
+Transcoded from I{Charles Karney}'s C++ class U{GARS
+<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GARS.html>}.
+
+@see: U{Global Area Reference System
+      <https://WikiPedia.org/wiki/Global_Area_Reference_System>} and U{NGA
+      (GARS)<https://Earth-Info.NGA.mil/GandG/coordsys/grids/gars.html>}.
 '''
 
 # from pygeodesy.basics import isstr  # from .named
 from pygeodesy.constants import _off90, _1_over, _0_5, \
                                 _1_0  # PYCHOK used!
-from pygeodesy.dms import parse3llh,   Fmt  # parseDMS2
 from pygeodesy.errors import _ValueError, _xkwds, _xStrError
-from pygeodesy.interns import NN, _0to9_, _AtoZnoIO_, _COMMA_
+from pygeodesy.interns import NN, _0to9_, _AtoZnoIO_, _COMMA_, _SPACE_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_OTHER
-from pygeodesy.named import _name__,  isstr, Property_RO
+from pygeodesy.named import _name__,  Fmt, isstr, Property_RO
 from pygeodesy.namedTuples import LatLon2Tuple, LatLonPrec3Tuple
 # from pygeodesy.props import Property_RO  # from .named
-# from pygeodesy.streprs import Fmt  # from .dms
+# from pygeodesy.streprs import Fmt  # from .named
 from pygeodesy.units import Int_, Lat, Lon, Precision_, Scalar_, Str
 
 from math import floor
 
 __all__ = _ALL_LAZY.gars
-__version__ = '24.06.15'
+__version__ = '24.08.02'
 
 _Digits  = _0to9_
 _LatLen  =    2
@@ -88,7 +88,7 @@ def _2garstr2(garef):
         if n < _MinLen or n > _MaxLen \
                        or garstr[:3] == 'INV' \
                        or not garstr.isalnum():
-            raise ValueError
+            raise ValueError()
         return garstr, _2Precision(n - _MinLen)
 
     except (AttributeError, TypeError, ValueError) as x:
@@ -111,45 +111,45 @@ class Garef(Str):
     '''Garef class, a named C{str}.
     '''
     # no str.__init__ in Python 3
-    def __new__(cls, cll, precision=1, **name):
-        '''New L{Garef} from an other L{Garef} instance or garef
-           C{str} or from a C{LatLon} instance or lat-/longitude C{str}.
-
-           @arg cll: Cell or location (L{Garef} or C{str}, C{LatLon}
-                     or C{str}).
-           @kwarg precision: Optional, the desired garef resolution
-                             and length (C{int} 0..2), see function
-                             L{gars.encode} for more details.
+    def __new__(cls, lat_gll, lon=None, precision=1, **name):
+        '''New L{Garef} from an other L{Garef} instance or garef C{str}
+           or from a lat- and longitude.
+
+           @arg lat_gll: Latitude (C{degrees90}), a garef (L{Garef},
+                         C{str}) or a location (C{LatLon}, C{LatLon*Tuple}).
+           @kwarg lon: Logitude (C{degrees180)}, required if B{C{lat_gll}}
+                       is C{degrees90}, ignored otherwise.
+           @kwarg precision: The desired garef resolution and length (C{int}
+                             0..2), see L{encode<pygeodesy.gars.encode>}.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: New L{Garef}.
 
-           @raise RangeError: Invalid B{C{cll}} lat- or longitude.
+           @raise GARSError: INValid B{C{lat_gll}}.
 
-           @raise TypeError: Invalid B{C{cll}}.
+           @raise RangeError: Invalid B{C{lat_gll}} or B{C{lon}}.
 
-           @raise GARSError: INValid or non-alphanumeric B{C{cll}}.
+           @raise TypeError: Invalid B{C{lat_gll}} or B{C{lon}}.
         '''
-        ll = p = None
-
-        if isinstance(cll, Garef):
-            g, p = _2garstr2(str(cll))
-
-        elif isstr(cll):
-            if _COMMA_ in cll:
-                ll = _2fll(*parse3llh(cll))
-                g  =  encode(*ll, precision=precision)  # PYCHOK false
-            else:
-                g = cll.upper()
-
-        else:  # assume LatLon
-            try:
-                ll = _2fll(cll.lat, cll.lon)
-                g  =  encode(*ll, precision=precision)  # PYCHOK false
-            except AttributeError:
-                raise _xStrError(Garef, cll=cll)  # Error=GARSError
-
-        self = Str.__new__(cls, g, name=_name__(name, _or_nameof=cll))
+        if lon is None:
+            if isinstance(lat_gll, Garef):
+                g, ll, p = str(lat_gll), lat_gll.latlon, lat_gll.precision
+            elif isstr(lat_gll):
+                ll = lat_gll.replace(_COMMA_, _SPACE_).split()
+                if len(ll) > 1:
+                    g, ll, p = _encode3(ll[0], ll[1], precision)
+                else:
+                    g, ll =  lat_gll.upper(), None
+                    _, p  = _2garstr2(g)  # validate
+            else:  # assume LatLon
+                try:
+                    g, ll, p = _encode3(lat_gll.lat, lat_gll.lon, precision)
+                except AttributeError:
+                    raise _xStrError(Garef, gll=lat_gll, Error=GARSError)
+        else:
+            g, ll, p = _encode3(lat_gll, lon, precision)
+
+        self = Str.__new__(cls, g, name=_name__(name, _or_nameof=lat_gll))
         self._latlon    = ll
         self._precision = p
         return self
@@ -251,7 +251,7 @@ def decode3(garef, center=True, **name):
                             precision, name=n)
 
 
-def encode(lat, lon, precision=1):  # MCCABE 14
+def encode(lat, lon, precision=1):
     '''Encode a lat-/longitude as a C{garef} of the given precision.
 
        @arg lat: Latitude (C{degrees}).
@@ -269,6 +269,13 @@ def encode(lat, lon, precision=1):  # MCCABE 14
               resolution is B{30′} for B{C{precision}} 0, B{15′} for 1
               and B{5′} for 2, respectively.
     '''
+    g, _, _ = _encode3(lat, lon, precision)
+    return g
+
+
+def _encode3(lat, lon, precision):  # MCCABE 14
+    '''Return 3-tuple C{(garef, (lat, lon), p)}.
+    '''
     def _digit(x, y, m):
         return _Digits[m * (m - y - 1) + x + 1],
 
@@ -282,12 +289,12 @@ def encode(lat, lon, precision=1):  # MCCABE 14
     p = _2Precision(precision)
 
     lat, lon = _2fll(lat, lon)
-    lat = _off90(lat)
 
-    ix, x = _2divmod2(lon, _LonOrig_M4)
-    iy, y = _2divmod2(lat, _LatOrig_M4)
+    ix, x = _2divmod2(       lon,  _LonOrig_M4)
+    iy, y = _2divmod2(_off90(lat), _LatOrig_M4)
 
-    g = _str(_Digits, ix + 1, _LonLen) + _str(_Letters, iy, _LatLen)
+    g = _str(_Digits,  ix + 1, _LonLen) + \
+        _str(_Letters, iy,     _LatLen)
     if p > 0:
         ix, x = divmod(x, _M3)
         iy, y = divmod(y, _M3)
@@ -295,7 +302,7 @@ def encode(lat, lon, precision=1):  # MCCABE 14
         if p > 1:
             g += _digit(x, y, _M3)
 
-    return NN.join(g)
+    return NN.join(g), (lat, lon), p
 
 
 def precision(res):