pygeodesy 24.12.12__py2.py3-none-any.whl → 25.1.9__py2.py3-none-any.whl

pygeodesy/latlonBase.py

@@ -20,7 +20,7 @@ from pygeodesy.dms import F_D, F_DMS, latDMS, lonDMS, parse3llh
 from pygeodesy.errors import _AttributeError, IntersectionError, \
                              _incompatible, _IsnotError, _TypeError, \
                              _ValueError, _xattr, _xdatum, _xError, \
-                             _xkwds, _xkwds_item2, _xkwds_not
+                             _xkwds, _xkwds_get, _xkwds_item2, _xkwds_not
 # from pygeodesy.fmath import favg  # _MODS
 # from pygeodesy.formy import antipode, compassAngle, cosineAndoyerLambert_, \
 #                             cosineForsytheAndoyerLambert_, cosineLaw, \
@@ -53,7 +53,7 @@ from contextlib import contextmanager
 from math import asin, cos, degrees, fabs, radians
 
 __all__ = _ALL_LAZY.latlonBase
-__version__ = '24.12.06'
+__version__ = '24.12.31'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -72,8 +72,8 @@ class LatLonBase(_NamedBase, _NamedLocal):
 
            @arg lat_llh: Latitude (C{degrees} or DMS C{str} with N or S suffix) or
                          a previous C{LatLon} instance provided C{B{lon}=None}.
-           @kwarg lon: Longitude (C{degrees} or DMS C{str} with E or W suffix) or
-                       C(None), indicating B{C{lat_llh}} is a C{LatLon}.
+           @kwarg lon: Longitude (C{degrees} or DMS C{str} with E or W suffix),
+                       required if B{C{lat_llh}} is C{degrees} or C{str}.
            @kwarg height: Optional height above (or below) the earth surface
                           (C{meter}, conventionally).
            @kwarg datum: Optional datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2},
@@ -362,67 +362,39 @@ class LatLonBase(_NamedBase, _NamedLocal):
         p = self.others(other)
         return _formy.compassAngle(self.lat, self.lon, p.lat, p.lon, **adjust_wrap)
 
+    @deprecated_method
     def cosineAndoyerLambertTo(self, other, **wrap):
-        '''Compute the distance between this and an other point using the U{Andoyer-Lambert correction<https://
-           navlib.net/wp-content/uploads/2013/10/admiralty-manual-of-navigation-vol-1-1964-english501c.pdf>}
-           of the U{Law of Cosines<https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>} formula.
-
-           @arg other: The other point (C{LatLon}).
-           @kwarg wrap: Optional keyword argument C{B{wrap}=False}, if C{True}, wrap or I{normalize}
-                        and unroll the B{C{other}} point (C{bool}).
-
-           @return: Distance (C{meter}, same units as the axes of this point's datum ellipsoid).
-
-           @raise TypeError: The B{C{other}} point is not C{LatLon}.
-
-           @see: Function L{pygeodesy.cosineAndoyerLambert} and methods
-                 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo},
-                 C{distanceTo*}, L{equirectangularTo}, L{euclideanTo},
-                 L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo}, L{haversineTo},
-                 L{thomasTo} and L{vincentysTo}.
-        '''
-        return self._distanceTo_(_formy.cosineAndoyerLambert_, other, **wrap)
+        '''DEPRECATED on 2024.12.31, use method L{cosineLawTo} with C{B{corr}=1}.'''
+        return self.cosineLawTo(other, corr=1, **wrap)
 
+    @deprecated_method
     def cosineForsytheAndoyerLambertTo(self, other, **wrap):
-        '''Compute the distance between this and an other point using the U{Forsythe-Andoyer-Lambert
-           correction<https://www2.UNB.Ca/gge/Pubs/TR77.pdf>} of the U{Law of Cosines
-           <https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>} formula.
+        '''DEPRECATED on 2024.12.31, use method L{cosineLawTo} with C{B{corr}=2}.'''
+        return self.cosineLawTo(other, corr=2, **wrap)
 
-           @arg other: The other point (C{LatLon}).
-           @kwarg wrap: Optional keyword argument C{B{wrap}=False}, if C{True}, wrap or I{normalize}
-                        and unroll the B{C{other}} point (C{bool}).
-
-           @return: Distance (C{meter}, same units as the axes of this point's datum ellipsoid).
-
-           @raise TypeError: The B{C{other}} point is not C{LatLon}.
-
-           @see: Function L{pygeodesy.cosineForsytheAndoyerLambert} and methods
-                 L{cosineAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
-                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
-                 L{flatPolarTo}, L{haversineTo}, L{thomasTo} and L{vincentysTo}.
-        '''
-        return self._distanceTo_(_formy.cosineForsytheAndoyerLambert_, other, **wrap)
-
-    def cosineLawTo(self, other, radius=None, **wrap):
-        '''Compute the distance between this and an other point using the U{spherical Law of
-           Cosines<https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>} formula.
+    def cosineLawTo(self, other, **radius__corr_wrap):
+        '''Compute the distance between this and an other point using the U{Law of
+           Cosines<https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>}
+           formula, optionally corrected.
 
            @arg other: The other point (C{LatLon}).
-           @kwarg radius: Mean earth radius (C{meter}) or C{None} for the mean radius of this
-                          point's datum ellipsoid.
-           @kwarg wrap: Optional keyword argument C{B{wrap}=False}, if C{True}, wrap or
-                        I{normalize} and unroll the B{C{other}} point (C{bool}).
+           @kwarg radius__corr_wrap: Optional earth C{B{radius}=None} (C{meter}),
+                          overriding the equatorial or mean radius of this point's
+                          datum's ellipsoid and keyword arguments for function
+                          L{pygeodesy.cosineLaw}.
 
            @return: Distance (C{meter}, same units as B{C{radius}}).
 
            @raise TypeError: The B{C{other}} point is not C{LatLon}.
 
-           @see: Function L{pygeodesy.cosineLaw} and methods L{cosineAndoyerLambertTo},
-                 L{cosineForsytheAndoyerLambertTo}, C{distanceTo*}, L{equirectangularTo},
-                 L{euclideanTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},
-                 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
+           @see: Function L{pygeodesy.cosineLaw} and methods C{distanceTo*},
+                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo} /
+                 L{hubenyTo}, L{flatPolarTo}, L{haversineTo}, L{thomasTo} and
+                 L{vincentysTo}.
         '''
-        return self._distanceTo(_formy.cosineLaw, other, radius, **wrap)
+        c = _xkwds_get(radius__corr_wrap, corr=0)
+        return self._distanceTo_(_formy.cosineLaw_, other, **radius__corr_wrap) if c else \
+               self._distanceTo( _formy.cosineLaw,  other, **radius__corr_wrap)
 
     @property_RO
     def datum(self):  # PYCHOK no cover
@@ -450,19 +422,18 @@ class LatLonBase(_NamedBase, _NamedLocal):
     def _distanceTo(self, func, other, radius=None, **kwds):
         '''(INTERNAL) Helper for distance methods C{<func>To}.
         '''
-        p, r = self.others(other, up=2), radius
-        if r is None:
-            r = self._datum.ellipsoid.R1 if self._datum else R_M
-        return func(self.lat, self.lon, p.lat, p.lon, radius=r, **kwds)
+        p = self.others(other, up=2)
+        R = radius or (self._datum.ellipsoid.R1 if self._datum else R_M)
+        return func(self.lat, self.lon, p.lat, p.lon, radius=R, **kwds)
 
-    def _distanceTo_(self, func_, other, wrap=False, radius=None):
+    def _distanceTo_(self, func_, other, wrap=False, radius=None, **kwds):
         '''(INTERNAL) Helper for (ellipsoidal) distance methods C{<func>To}.
         '''
         p = self.others(other, up=2)
-        D = self.datum
+        D = self.datum or _spherical_datum(radius or R_M, func_)
         lam21, phi2, _ = _Wrap.philam3(self.lam, p.phi, p.lam, wrap)
-        r = func_(phi2, self.phi, lam21, datum=D)
-        return r * (D.ellipsoid.a if radius is None else radius)
+        r = func_(phi2, self.phi, lam21, datum=D, **kwds)
+        return r * (radius or D.ellipsoid.a)
 
     @Property_RO
     def _Ecef_forward(self):
@@ -511,10 +482,9 @@ class LatLonBase(_NamedBase, _NamedLocal):
 
            @raise TypeError: The B{C{other}} point is not C{LatLon}.
 
-           @see: Function L{pygeodesy.equirectangular} and methods L{cosineAndoyerLambertTo},
-                 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
-                 C{euclideanTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},
-                 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
+           @see: Function L{pygeodesy.equirectangular} and methods L{cosineLawTo},
+                 C{distanceTo*}, C{euclideanTo}, L{flatLocalTo} / L{hubenyTo},
+                 L{flatPolarTo}, L{haversineTo}, L{thomasTo} and L{vincentysTo}.
         '''
         return self._distanceTo(_formy.equirectangular, other, **radius_adjust_limit_wrap)
 
@@ -533,9 +503,8 @@ class LatLonBase(_NamedBase, _NamedLocal):
 
            @raise TypeError: The B{C{other}} point is not C{LatLon}.
 
-           @see: Function L{pygeodesy.euclidean} and methods L{cosineAndoyerLambertTo},
-                 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
-                 L{equirectangularTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},
+           @see: Function L{pygeodesy.euclidean} and methods L{cosineLawTo}, C{distanceTo*},
+                 L{equirectangularTo}, L{flatLocalTo} / L{hubenyTo}, L{flatPolarTo},
                  L{haversineTo}, L{thomasTo} and L{vincentysTo}.
         '''
         return self._distanceTo(_formy.euclidean, other, **radius_adjust_wrap)
@@ -558,11 +527,10 @@ class LatLonBase(_NamedBase, _NamedLocal):
 
            @raise ValueError: Invalid B{C{radius}}.
 
-           @see: Function L{pygeodesy.flatLocal}/L{pygeodesy.hubeny}, methods
-                 L{cosineAndoyerLambertTo}, L{cosineForsytheAndoyerLambertTo},
-                 L{cosineLawTo}, C{distanceTo*}, L{equirectangularTo}, L{euclideanTo},
-                 L{flatPolarTo}, L{haversineTo}, L{thomasTo} and L{vincentysTo} and
-                 U{local, flat Earth approximation<https://www.edwilliams.org/avform.htm#flat>}.
+           @see: Function L{pygeodesy.flatLocal}/L{pygeodesy.hubeny}, methods L{cosineLawTo},
+                 C{distanceTo*}, L{equirectangularTo}, L{euclideanTo}, L{flatPolarTo},
+                 L{haversineTo}, L{thomasTo} and L{vincentysTo} and U{local, flat Earth
+                 approximation<https://www.edwilliams.org/avform.htm#flat>}.
         '''
         r = radius if radius in (None, R_M, _1_0, 1) else Radius(radius)
         return self._distanceTo_(_formy.flatLocal_, other, radius=r, **wrap)  # PYCHOK kwargs
@@ -583,9 +551,8 @@ class LatLonBase(_NamedBase, _NamedLocal):
 
            @raise TypeError: The B{C{other}} point is not C{LatLon}.
 
-           @see: Function L{pygeodesy.flatPolar} and methods L{cosineAndoyerLambertTo},
-                 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
-                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
+           @see: Function L{pygeodesy.flatPolar} and methods L{cosineLawTo}, C{distanceTo*},
+                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo} / L{hubenyTo},
                  L{haversineTo}, L{thomasTo} and L{vincentysTo}.
         '''
         return self._distanceTo(_formy.flatPolar, other, **radius_wrap)
@@ -627,9 +594,8 @@ class LatLonBase(_NamedBase, _NamedLocal):
 
            @raise TypeError: The B{C{other}} point is not C{LatLon}.
 
-           @see: Function L{pygeodesy.haversine} and methods L{cosineAndoyerLambertTo},
-                 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
-                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
+           @see: Function L{pygeodesy.haversine} and methods L{cosineLawTo}, C{distanceTo*},
+                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo} / L{hubenyTo}, \
                  L{flatPolarTo}, L{thomasTo} and L{vincentysTo}.
         '''
         return self._distanceTo(_formy.haversine, other, **radius_wrap)
@@ -1310,9 +1276,8 @@ class LatLonBase(_NamedBase, _NamedLocal):
 
            @raise TypeError: The B{C{other}} point is not C{LatLon}.
 
-           @see: Function L{pygeodesy.thomas} and methods L{cosineAndoyerLambertTo},
-                 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
-                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
+           @see: Function L{pygeodesy.thomas} and methods L{cosineLawTo}, C{distanceTo*},
+                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo} / L{hubenyTo},
                  L{flatPolarTo}, L{haversineTo} and L{vincentysTo}.
         '''
         return self._distanceTo_(_formy.thomas_, other, **wrap)
@@ -1323,8 +1288,8 @@ class LatLonBase(_NamedBase, _NamedLocal):
         return self.philam
 
     def toCartesian(self, height=None, Cartesian=None, **Cartesian_kwds):
-        '''Convert this point to cartesian, I{geocentric} coordinates, also known
-           as I{Earth-Centered, Earth-Fixed} (ECEF).
+        '''Convert this point to cartesian, I{geocentric} coordinates, also known as
+           I{Earth-Centered, Earth-Fixed} (ECEF).
 
            @kwarg height: Optional height, overriding this point's height (C{meter},
                           conventionally).
@@ -1533,9 +1498,8 @@ class LatLonBase(_NamedBase, _NamedLocal):
 
            @raise TypeError: The B{C{other}} point is not C{LatLon}.
 
-           @see: Function L{pygeodesy.vincentys} and methods L{cosineAndoyerLambertTo},
-                 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
-                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
+           @see: Function L{pygeodesy.vincentys} and methods L{cosineLawTo}, C{distanceTo*},
+                 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo} / L{hubenyTo},
                  L{flatPolarTo}, L{haversineTo} and L{thomasTo}.
         '''
         return self._distanceTo(_formy.vincentys, other, **_xkwds(radius_wrap, radius=None))

pygeodesy/lazily.py

@@ -36,7 +36,7 @@ from pygeodesy.interns import NN, _attribute_, _by_, _COLONSPACE_, _COMMASPACE_,
                              _doesn_t_exist_, _DOT_, _DUNDER_all_, _EQUALSPACED_, \
                              _from_, _HASH_, _immutable_, _line_, _module_, _no_, \
                              _not_, _or_, _pygeodesy_abspath_, _pygeodesy_,  _sys, \
-                             _SUB_PACKAGES, _UNDER_, _version_, _intern  # function
+                             _SUB_PACKAGES, _UNDER_, _version_,  _intern  # function
 try:
     from importlib import import_module
 except ImportError as x:  # Python 2.6-
@@ -184,10 +184,10 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'equidistant', 'gnomonic'),
                          basics=_a('clips', 'copysign0', 'copytype', 'halfs2',
                                    'int1s', 'isbool', 'isCartesian', 'isclass', 'iscomplex', 'isDEPRECATED', 'isfloat',
-                                   'isidentifier', 'isinstanceof', 'isint', 'isiterable', 'isiterablen', 'iskeyword',
-                                   'isLatLon', 'islistuple', 'isNvector', 'isodd', 'isscalar', 'issequence', 'isstr',
-                                   'issubclassof', 'itemsorted',
-                                   'len2', 'map1', 'map2', 'neg', 'neg_',
+                                   'isidentifier', 'isinstanceof', 'isint', 'isiterable', 'isiterablen', 'isiterabletype',
+                                   'iskeyword', 'isLatLon', 'islistuple', 'isNvector', 'isodd',
+                                   'isscalar', 'issequence', 'isstr', 'issubclassof', 'itemsorted',
+                                   'len2', 'map1', 'map2', 'max2', 'min2', 'neg', 'neg_',
                                    'signBit', 'signOf', 'splice', 'str2ub', 'ub2str', 'unsigned0'),
                        booleans=_a('BooleanFHP', 'BooleanGH', 'LatLonFHP', 'LatLonGH',
                                    'isBoolean'),
@@ -246,9 +246,8 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',
                                    'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'),
                           formy=_a('Radical2Tuple',
-                                   'angle2chord', 'antipode', 'antipode_', 'bearing', 'bearing_', 'chord2angle',
-                                   'compassAngle', 'cosineForsytheAndoyerLambert', 'cosineForsytheAndoyerLambert_',
-                                   'cosineAndoyerLambert', 'cosineAndoyerLambert_', 'cosineLaw', 'cosineLaw_',
+                                   'angle2chord', 'antipode', 'antipode_', 'bearing', 'bearing_',
+                                   'chord2angle', 'compassAngle', 'cosineLaw', 'cosineLaw_',
                                    'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_',
                                    'excessAbc_', 'excessCagnoli_', 'excessGirard_', 'excessLHuilier_',
                                    'excessKarney', 'excessKarney_', 'excessQuad', 'excessQuad_',
@@ -257,12 +256,10 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'intersection2', 'intersections2', 'isantipode', 'isantipode_', 'isnormal', 'isnormal_',
                                    'normal', 'normal_', 'opposing', 'opposing_', 'radical2',
                                    'thomas', 'thomas_', 'vincentys', 'vincentys_'),
-                        frechet=_a('Frechet', 'FrechetDegrees', 'FrechetError', 'FrechetRadians',
-                                   'FrechetCosineAndoyerLambert', 'FrechetCosineForsytheAndoyerLambert',
-                                   'FrechetCosineLaw', 'FrechetDistanceTo', 'FrechetEquirectangular',
-                                   'FrechetEuclidean', 'FrechetExact', 'FrechetFlatLocal', 'FrechetFlatPolar',
-                                   'FrechetHaversine', 'FrechetHubeny', 'FrechetKarney', 'FrechetThomas',
-                                   'FrechetVincentys', 'Frechet6Tuple',
+                        frechet=_a('Frechet', 'FrechetDegrees', 'FrechetError', 'FrechetRadians', 'FrechetCosineLaw',
+                                   'FrechetDistanceTo', 'FrechetEquirectangular', 'FrechetEuclidean', 'FrechetExact',
+                                   'FrechetFlatLocal', 'FrechetFlatPolar', 'FrechetHaversine', 'FrechetHubeny', 'FrechetKarney',
+                                   'FrechetThomas', 'FrechetVincentys', 'Frechet6Tuple',
                                    'frechet_'),
                          fstats=_a('Fcook', 'Flinear', 'Fwelford'),
                           fsums=_a('Fsum', 'DivMod2Tuple', 'Fsum2Tuple', 'ResidualError',
@@ -275,20 +272,16 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'),
                       geodsolve=_a('GeodesicSolve', 'GeodesicLineSolve', 'GeodSolve12Tuple'),
                         geohash=_a('Geohash', 'Geohashed', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple', 'Sizes3Tuple'),
-                         geoids=_a('GeoidError', 'GeoidG2012B', 'GeoidKarney', 'GeoidPGM', 'egmGeoidHeights',
+                         geoids=_a('GeoidError', 'GeoidEGM96', 'GeoidG2012B', 'GeoidKarney', 'GeoidPGM', 'egmGeoidHeights',
                                    'PGMError', 'GeoidHeight5Tuple'),
-                      hausdorff=_a('Hausdorff', 'HausdorffDegrees', 'HausdorffError', 'HausdorffRadians',
-                                   'HausdorffCosineAndoyerLambert', 'HausdorffCosineForsytheAndoyerLambert',
-                                   'HausdorffCosineLaw', 'HausdorffDistanceTo', 'HausdorffEquirectangular',
-                                   'HausdorffEuclidean', 'HausdorffExact', 'HausdorffFlatLocal', 'HausdorffFlatPolar',
-                                   'HausdorffHaversine', 'HausdorffHubeny', 'HausdorffKarney', 'HausdorffThomas',
-                                   'HausdorffVincentys', 'Hausdorff6Tuple',
+                      hausdorff=_a('Hausdorff', 'HausdorffDegrees', 'HausdorffError', 'HausdorffRadians', 'HausdorffCosineLaw',
+                                   'HausdorffDistanceTo', 'HausdorffEquirectangular', 'HausdorffEuclidean', 'HausdorffExact',
+                                   'HausdorffFlatLocal', 'HausdorffFlatPolar', 'HausdorffHaversine', 'HausdorffHubeny',
+                                   'HausdorffKarney', 'HausdorffThomas', 'HausdorffVincentys', 'Hausdorff6Tuple',
                                    'hausdorff_', 'randomrangenerator'),
-                        heights=_a('HeightCubic', 'HeightError',
-                                   'HeightIDWcosineAndoyerLambert', 'HeightIDWcosineForsytheAndoyerLambert',
-                                   'HeightIDWcosineLaw', 'HeightIDWdistanceTo', 'HeightIDWequirectangular',
-                                   'HeightIDWeuclidean', 'HeightIDWexact', 'HeightIDWflatLocal', 'HeightIDWflatPolar',
-                                   'HeightIDWhaversine', 'HeightIDWhubeny', 'HeightIDWkarney', 'HeightIDWthomas',
+                        heights=_a('HeightCubic', 'HeightError', 'HeightIDWcosineLaw', 'HeightIDWdistanceTo',
+                                   'HeightIDWequirectangular', 'HeightIDWeuclidean', 'HeightIDWexact', 'HeightIDWflatLocal',
+                                   'HeightIDWflatPolar', 'HeightIDWhaversine', 'HeightIDWhubeny', 'HeightIDWkarney', 'HeightIDWthomas',
                                    'HeightIDWvincentys', 'HeightLinear', 'HeightLSQBiSpline', 'HeightSmoothBiSpline'),
                       internals=_internals.__all__,
                         interns=_interns.__all__,
@@ -361,17 +354,17 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'Radius_', 'Scalar', 'Scalar_', 'Zone'),
                       unitsBase=_a('Float', 'Int', 'Radius', 'Str'),
                             ups=_a('Ups', 'UPSError', 'parseUPS5', 'toUps8', 'upsZoneBand5'),
-                          utily=_a('acos1', 'acre2ha', 'acre2m2', 'asin1', 'atan1', 'atan1d', 'atan2b', 'atan2d',
+                          utily=_a('acos1', 'acre2ha', 'acre2m2', 'asin1', 'atan1', 'atan1d', 'atan2', 'atan2b', 'atan2d',
                                    'chain2m', 'circle4', 'cot', 'cot_', 'cotd', 'cotd_',
                                    'degrees', 'degrees90', 'degrees180', 'degrees360', 'degrees2grades', 'degrees2m',
-#                                                                                      'degrees2grades as degrees2gons',
-                                   'fathom2m', 'ft2m', 'furlong2m',
+                                   'fathom2m', 'ft2m', 'furlong2m',                  # 'degrees2grades as degrees2gons',
                                    'grades', 'grades400', 'grades2degrees', 'grades2radians',
 #                                  'grades as gons', 'grades400 as gons400', 'grades2degrees as gons2degrees', 'grades2radians as gons2radians',
-                                   'km2m', 'm2chain', 'm2degrees', 'm2fathom', 'm2ft', 'm2furlong',
-                                   'm2km', 'm2NM', 'm2radians', 'm2SM', 'm2toise', 'm2yard', 'NM2m',
-                                   'radians', 'radiansPI', 'radiansPI2', 'radiansPI_2', 'radians2m',
-                                   'sincos2', 'SinCos2', 'sincos2_', 'sincos2d', 'sincos2d_', 'sincostan3', 'SM2m',
+                                   'ha2acre', 'ha2m2', 'hav', 'km2m',
+                                   'm2acre', 'm2chain', 'm2degrees', 'm2fathom', 'm2ft', 'm2furlong',
+                                   'm2ha', 'm2km', 'm2NM', 'm2radians', 'm2SM', 'm2toise', 'm2yard',
+                                   'NM2m', 'radians', 'radiansPI', 'radiansPI2', 'radiansPI_2', 'radians2m',
+                                   'sincos2', 'SinCos2', 'sincos2_', 'sincos2d', 'sincos2d_', 'sincostan3', 'sincostan3d', 'SM2m',
                                    'tan', 'tan_', 'tand', 'tand_', 'tan_2', 'tanPI_2_2', 'toise2m', 'truncate',
                                    'unroll180', 'unrollPI',
                                    'wrap90', 'wrap180', 'wrap360', 'wrapPI_2', 'wrapPI', 'wrapPI2', 'wrap_normal',
@@ -393,7 +386,10 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                                          'rhumbaux', 'rhumbBase', 'rhumbsolve', 'rhumbx'),  # ... names
                      deprecated_bases=_a('LatLonHeightBase', 'points2'),
                    deprecated_classes=_a('ClipCS3Tuple', 'EasNorExact4Tuple', 'EcefCartesian', 'Fn_rt',
-                                         'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'Helmert7Tuple',
+                                         'FrechetCosineAndoyerLambert', 'FrechetCosineForsytheAndoyerLambert',
+                                         'HausdorffCosineAndoyerLambert', 'HausdorffCosineForsytheAndoyerLambert',
+                                         'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'HeightIDWcosineAndoyerLambert',
+                                         'HeightIDWcosineForsytheAndoyerLambert', 'Helmert7Tuple',
                                          'Lam_', 'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple',
                                          'Phi_', 'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple',
                                          'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple', 'XDist'),
@@ -403,6 +399,8 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                                          'R_FM', 'R_KM', 'R_M', 'R_MA', 'R_MB', 'R_NM', 'R_SM', 'R_VM'),
                  deprecated_functions=_a('anStr', 'areaof', 'atand', 'bounds',  # most of the DEPRECATED functions, except ellipsoidal ...
                                          'clipCS3', 'clipDMS', 'clipStr', 'collins', 'copysign',  # ... and spherical flavors
+                                         'cosineAndoyerLambert', 'cosineAndoyerLambert_',
+                                         'cosineForsytheAndoyerLambert', 'cosineForsytheAndoyerLambert_',
                                          'decodeEPSG2', 'encodeEPSG', 'enStr2', 'equirectangular_', 'equirectangular3',
                                          'excessAbc', 'excessGirard', 'excessLHuilier',
                                          'false2f', 'falsed2f', 'float0', 'fStr', 'fStrzs', 'Fsum2product',
@@ -511,7 +509,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.11.28'
+__version__ = '25.01.05'
 
 
 def _ALL_OTHER(*objs):
@@ -548,6 +546,17 @@ def _all_deprecates():
 _ALL_DEPRECATES = _Dict()  # PYCHOK _ALL_DEPRECATED.imports()
 
 
+def _all_enums():
+    '''(INTERNAL) Yield all C{(mod_, tuple)} pairs for C{__init__._all}.
+    '''
+    # assert _init__all__
+    for mod_t in _ALL_LAZY.enums():
+        yield mod_t
+    if _FOR_DOCS:
+        for mod_t in _ALL_DEPRECATED.enums():
+            yield mod_t
+
+
 def _all_imports():
     '''(INTERNAL) Build C{dict} of all lazy imports.
     '''

pygeodesy/ltpTuples.py

@@ -3,8 +3,8 @@
 
 u'''Named, I{Local Tangent Plane} (LTP) tuples.
 
-Local coordinate classes L{XyzLocal}, L{Enu}, L{Ned} and L{Aer}
-and local coordinate tuples L{Local9Tuple}, L{Xyz4Tuple}, L{Enu4Tuple},
+Local coordinate classes L{XyzLocal}, L{Enu}, L{Ned} and L{Aer} and
+local coordinate tuples L{Local9Tuple}, L{Xyz4Tuple}, L{Enu4Tuple},
 L{Ned4Tuple}, L{Aer4Tuple}, L{ChLV9Tuple}, L{ChLVEN2Tuple},
 L{ChLVYX2Tuple}, L{ChLVyx2Tuple} and L{Footprint5Tuple}.
 

pygeodesy/named.py

@@ -926,21 +926,21 @@ class _NamedLocal(object):
         '''
         return _MODS.ltp
 
-    def _ltp_toLocal(self, ltp, Cls_and_kwds, **nam_Cls):  # overloaded in C{Ecef9Tuple}
+    def _ltp_toLocal(self, ltp, Xyz_kwds, **Xyz):  # overloaded in C{Ecef9Tuple}
         '''(INTERNAL) Invoke C{ltp._toLocal}.
         '''
-        Cls, kwds = self._ltp_toLocal2(Cls_and_kwds, **nam_Cls)
-        return self._ltp._toLocal(self, ltp, Cls, kwds)  # self._ecef9
+        Xyz_ = self._ltp_toLocal2(Xyz_kwds, **Xyz)
+        return self._ltp._toLocal(self, ltp, *Xyz_)  # self._ecef9
 
-    def _ltp_toLocal2(self, Cls_and_kwds, _None=None, **nam_Cls):
-        '''(INTERNAL) Return 2-tuple C{(Cls, kwds)}.
+    def _ltp_toLocal2(self, Xyz_kwds, _None=None, **Xyz):
+        '''(INTERNAL) Return 2-tuple C{(Xyz_Class, Xyz_kwds)}.
         '''
-        Cls, kwds = _xkwds_pop2(Cls_and_kwds, **nam_Cls)
-        if Cls is not _None:  # validate Cls
-            n, LoC = _xkwds_item2(nam_Cls)
-            if LoC is not Cls:
-                _xsubclassof(LoC, **{n: Cls})
-        return Cls, kwds
+        C, _ = Xyz_ = _xkwds_pop2(Xyz_kwds, **Xyz)
+        if C is not _None:  # validate C
+            n, X = _xkwds_item2(Xyz)
+            if X is not C:
+                _xsubclassof(X, **{n: C})
+        return Xyz_
 
     @property_ROver
     def _ltpTuples(self):