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

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-
@@ -45,7 +45,7 @@ except ImportError as x:  # Python 2.6-
 
 _a0                = ()  # PYCHOK empty tuple
 _asSPACED_         = ' as '
-_FOR_DOCS          = _getPYGEODESY('_FOR_DOCS')  # for epydoc ...
+_FOR_DOCS          = _getPYGEODESY('FOR_DOCS')  # for epydoc ...
 _init__all__       = _FOR_DOCS or _getPYGEODESY('_init__all__', _DUNDER_all_) == _DUNDER_all_  # PYCHOK exported
 _lazily_           = 'lazily'
 _PYTHON_X_DEV      =  getattr(_sys.flags, 'dev_mode', False)  # PYCHOK Python 3.2+
@@ -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,24 +246,20 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',
                                    'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'),
                           formy=_a('Radical2Tuple',
-                                   'antipode', 'antipode_', 'bearing', 'bearing_',
-                                   '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_',
                                    'flatLocal', 'flatLocal_', 'flatPolar', 'flatPolar_',
                                    'hartzell', 'haversine', 'haversine_', 'heightOf', 'heightOrthometric', 'horizon', 'hubeny', 'hubeny_',
                                    'intersection2', 'intersections2', 'isantipode', 'isantipode_', 'isnormal', 'isnormal_',
-                                   'latlon2n_xyz', 'normal', 'normal_', 'n_xyz2latlon', 'n_xyz2philam',
-                                   'opposing', 'opposing_', 'philam2n_xyz', 'radical2',
+                                   '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',
@@ -276,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__,
@@ -297,7 +289,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'isNumpy2', 'isPoints2', 'isTuple2', 'iterNumpy2', 'iterNumpy2over'),
                          karney=_a('Area3Tuple', 'Caps', 'Direct9Tuple', 'GDict', 'Inverse10Tuple', 'Rhumb8Tuple'),
                             ktm=_a('KTMError', 'KTransverseMercator'),
-                     latlonBase=_a(),  # module only
+                     latlonBase=_a('latlon2n_xyz', 'philam2n_xyz'),
                          lazily=_a('LazyAttributeError', 'LazyImportError', 'isLazy'),
                             lcc=_a('Conic', 'Conics', 'Lcc', 'LCCError', 'toLcc'),
                             ltp=_a('Attitude', 'AttitudeError', 'ChLV', 'ChLVa', 'ChLVe', 'Frustum',
@@ -322,7 +314,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'Reverse4Tuple', 'Triangle7Tuple', 'Triangle8Tuple', 'Trilaterate5Tuple',
                                    'UtmUps2Tuple', 'UtmUps5Tuple', 'UtmUps8Tuple', 'UtmUpsLatLon5Tuple',
                                    'Vector2Tuple', 'Vector3Tuple', 'Vector4Tuple'),
-                    nvectorBase=_a('NorthPole', 'SouthPole'),
+                    nvectorBase=_a('NorthPole', 'SouthPole', 'n_xyz2latlon', 'n_xyz2philam'),
                            osgr=_a('Osgr', 'OSGRError', 'parseOSGR', 'toOsgr'),
                          points=_a('LatLon_', 'LatLon2psxy', 'Numpy2LatLon', 'Shape2Tuple', 'Tuple2LatLon',
                                    'areaOf', 'boundsOf', 'centroidOf', 'fractional',
@@ -344,7 +336,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                   sphericalBase=_a(),  # module only
                sphericalNvector=_a(),  # module only
           sphericalTrigonometry=_a(),  # module only
-                       simplify=_a('simplify1', 'simplifyRDP', 'simplifyRDPm', 'simplifyRW', 'simplifyVW', 'simplifyVWm'),
+                       simplify=_a('simplify1', 'simplifyRDP', 'simplifyRW', 'simplifyVW'),
                       solveBase=_a(),  # module only
                         streprs=_a('anstr', 'attrs', 'enstr2', 'fstr', 'fstrzs', 'hstr', 'instr',
                                    'lrstrip', 'pairs', 'reprs', 'strs', 'unstr'),
@@ -362,18 +354,18 @@ _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',
-                                   'tand', 'tand_', 'tan_2', 'tanPI_2_2', 'toise2m', 'truncate',
+                                   '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',
                                    'yard2m'),
@@ -394,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'),
@@ -404,12 +399,15 @@ _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',
                                          'hypot3', 'inStr', 'isenclosedby', 'istuplist',
                                          'joined', 'joined_', 'nearestOn3', 'nearestOn4',
-                                         'parseUTM', 'perimeterof', 'polygon', 'scalar', 'simplify2',
+                                         'parseUTM', 'perimeterof', 'polygon',
+                                         'scalar', 'simplify2', 'simplifyRDPm', 'simplifyVWm',
                                          'tienstra', 'toUtm', 'triAngle4',
                                          'unsign0', 'unStr', 'utmZoneBand2'),
                    deprecated_nvector=_a('LatLonNvectorBase', 'Nvector', 'sumOf', 'NorthPole', 'SouthPole'),)
@@ -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.09'
+__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.
     '''
@@ -899,7 +908,7 @@ if _is_DUNDER_main(__name__):  # PYCHOK no cover
 
 # **) MIT License
 #
-# Copyright (C) 2018-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2018-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/lcc.py

@@ -659,7 +659,7 @@ if __name__ == '__main__':
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/ltp.py

@@ -23,8 +23,8 @@ from pygeodesy.ecef import _EcefBase, EcefKarney, Ecef9Tuple, _llhn4, \
                            _xyzn4,  _WGS84
 from pygeodesy.errors import _NotImplementedError, _ValueError, _xattr, \
                              _xkwds, _xkwds_get, _xkwds_pop2
-from pygeodesy.fmath import fabs, fdot, Fhorner
-from pygeodesy.fsums import _floor, _Fsumf_, fsumf_, fsum1f_
+from pygeodesy.fmath import fabs, fdot, fdot_, Fhorner
+from pygeodesy.fsums import _floor, fsumf_
 from pygeodesy.interns import _0_, _COMMASPACE_, _DOT_, _ecef_, _height_, _M_, \
                               _invalid_, _lat0_, _lon0_, _name_, _too_
 # from pygeodesy.lazily import _ALL_LAZY  # from vector3d
@@ -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.11.06'
+__version__ = '24.12.12'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -119,14 +119,13 @@ class Attitude(_NamedBase):
            @see: Matrix M of case 10 in U{Appendix A
                  <https://ntrs.NASA.gov/api/citations/19770019231/downloads/19770019231.pdf>}.
         '''
-        _f = fsum1f_
         # to follow the definitions of rotation angles alpha, beta and gamma:
         # negate yaw since yaw is counter-clockwise around the z-axis, swap
         # tilt and roll since tilt is around the x- and roll around the y-axis
         sa, ca, sb, cb, sg, cg = sincos2d_(-self.yaw, self.roll, self.tilt)
-        return ((ca * cb, _f(ca * sb * sg, -sa * cg), _f(ca * sb * cg,  sa * sg)),
-                (sa * cb, _f(sa * sb * sg,  ca * cg), _f(sa * sb * cg, -ca * sg)),
-                (    -sb,         cb * sg,                    cb * cg))
+        return ((ca * cb, fdot_(ca, sb * sg, -sa, cg), fdot_(ca, sb * cg,  sa, sg)),
+                (sa * cb, fdot_(sa, sb * sg,  ca, cg), fdot_(sa, sb * cg, -ca, sg)),
+                (    -sb,           cb * sg,                     cb * cg))
 
     @property_doc_(' roll/bank in C{degrees180}, positive to the right and down.')
     def roll(self):
@@ -159,7 +158,7 @@ class Attitude(_NamedBase):
 
            @raise AttitudeError: Invalid B{C{x_xyz}}, B{C{y}} or B{C{z}}.
 
-           @raise TypeError: Invalid B{C{Vector}} or B{C{name_Vector_kwds}}.
+           @raise TypeError: Invalid B{C{Vector}} or B{C{name_Vector_kwds}} item.
 
            @see: U{Yaw, pitch, and roll rotations<http://MSL.CS.UIUC.edu/planning/node102.html>}.
         '''
@@ -308,11 +307,10 @@ class Frustum(_NamedBase):
 
         def _xyz5(b, xy5, z, ltp):
             # rotate (x, y)'s by bearing, clockwise
-            s, c = sincos2d(b)
-            _f   = fsum1f_
+            sc = sincos2d(b)
             for x, y in xy5:
-                yield Xyz4Tuple(_f(x * c,  y * s),
-                                _f(y * c, -x * s), z, ltp)
+                yield Xyz4Tuple(fdot(sc,  x, y),
+                                fdot(sc, -x, y), z, ltp)
 
         try:
             a, t, y, r = alt_attitude.atyr
@@ -330,7 +328,7 @@ class Frustum(_NamedBase):
         else:
             z = _0_0
 
-        b =  Degrees(yaw=y, wrap=wrap360)  # bearing
+        b =  Degrees(yaw=y,  wrap=wrap360)  # bearing
         e = -Degrees(tilt=t, wrap=wrap180)  # elevation, pitch
         if not EPS < e < _180_0:
             raise _ValueError(tilt=t)
@@ -468,7 +466,7 @@ class LocalCartesian(_NamedBase):
         '''(INTERNAL) Convert geocentric/geodetic to local, like I{forward}.
 
            @arg ecef: Geocentric (and geodetic) (L{Ecef9Tuple}).
-           @arg Xyz: An L{XyzLocal}, L{Enu} or L{Ned} I{class} or C{None}.
+           @arg Xyz: An L{XyzLocal}, L{Aer}, L{Enu} or L{Ned} I{class} or C{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}.
@@ -479,16 +477,15 @@ class LocalCartesian(_NamedBase):
                     (L{Ecef9Tuple}) converted to this C{datum} and C{M=None},
                     always.
 
-           @raise TypeError: Invalid B{C{Xyz}} or B{C{name_Xyz_kwds}}.
+           @raise TypeError: Invalid B{C{Xyz}} or B{C{name_Xyz_kwds}} item.
         '''
         _xinstanceof(Ecef9Tuple, ecef=ecef)
-        ltp = self
-        if ecef.datum != ltp.datum:
-            ecef = ecef.toDatum(ltp.datum)
+        if ecef.datum != self.datum:
+            ecef = ecef.toDatum(self.datum)
         n, kwds = _name2__(name_Xyz_kwds, _or_nameof=ecef)
-        x, y, z =  self.M.rotate(ecef.xyz, *ltp._t0_xyz)
+        x, y, z =  self.M.rotate(ecef.xyz, *self._t0_xyz)
         r = Local9Tuple(x, y, z, ecef.lat, ecef.lon, ecef.height,
-                                 ltp, ecef, None, name=n)
+                                 self, ecef, None, name=n)
         if Xyz:
             _xsubclassof(*_XyzLocals4, Xyz=Xyz)  # Vector3d
             r = r.toXyz(Xyz=Xyz, name=n, **kwds)
@@ -557,9 +554,9 @@ class LocalCartesian(_NamedBase):
            @kwarg nine: If C{True}, return a 9-, otherwise a 3-tuple (C{bool}).
            @kwarg M: Include the rotation matrix (C{bool}).
 
-           @return: A I{geocentric} 3-tuple C{(x, y, z)} or if C{B{nine}=True},
-                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)},
-                    optionally including rotation matrix C{M} otherwise C{None}.
+           @return: A I{geocentric} 3-tuple C{(x, y, z)} or if C{B{nine}=True}, an
+                    L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
+                    rotation matrix C{M} (L{EcefMatrix}) if requested.
         '''
         _xinstanceof(*_XyzLocals5, local=local)
         t = self.M.unrotate(local.xyz, *self._t0_xyz)
@@ -959,15 +956,15 @@ class ChLVa(_ChLV, LocalCartesian):
         a,  b, h_      = _ChLV._llh2abh_3(lat, lon, h)
         a2, b2         =  a**2, b**2
 
-        Y = fsumf_( 72.37, 211455.93 * b,
-                           -10938.51 * b * a,
-                               -0.36 * b * a2,
-                              -44.54 * b * b2)  # + 600_000
-        X = fsumf_(147.07, 308807.95 * a,
-                             3745.25 * b2,
-                               76.63 * a2,
-                             -194.56 * b2 * a,
-                              119.79 * a2 * a)  # + 200_000
+        Y = fdot_(211455.93, b,
+                  -10938.51, b * a,
+                      -0.36, b * a2,
+                     -44.54, b * b2, start=72.37)  # + 600_000
+        X = fdot_(308807.95, a,
+                    3745.25, b2,
+                      76.63, a2,
+                    -194.56, b2 * a,
+                     119.79, a2 * a, start=147.07)  # + 200_000
         return self._ChLV9Tuple(True, M, n, Y, X, h_, lat, lon, h)
 
     def reverse(self, enh_, n=None, h_=0, M=None, **name):  # PYCHOK signature
@@ -976,15 +973,15 @@ class ChLVa(_ChLV, LocalCartesian):
         a, b, h      = _ChLV._YXh_2abh3(Y, X, h_)
         ab_d, a2, b2 =  ChLV._ab_d, a**2, b**2
 
-        lat = _Fsumf_(16.9023892, 3.238272 * b,
-                                 -0.270978 * a2,
-                                 -0.002528 * b2,
-                                 -0.0447   * a2 * b,
-                                 -0.014    * b2 * b).fover(ab_d)
-        lon = _Fsumf_( 2.6779094, 4.728982 * a,
-                                  0.791484 * a * b,
-                                  0.1306   * a * b2,
-                                 -0.0436   * a * a2).fover(ab_d)
+        lat = fdot_(3.238272, b,
+                   -0.270978, a2,
+                   -0.002528, b2,
+                     -0.0447, a2 * b,
+                      -0.014, b2 * b, start=16.9023892) / ab_d
+        lon = fdot_(4.728982, a,
+                    0.791484, a * b,
+                      0.1306, a * b2,
+                     -0.0436, a * a2, start=2.6779094) / ab_d
         return self._ChLV9Tuple(False, M, n, Y, X, h_, lat, lon, h)
 
 
@@ -1025,8 +1022,7 @@ class ChLVe(_ChLV, LocalCartesian):
         B0 = _H(a,    z,      308770.746371, 75.028131, 120.435227, 0.009488, 0.070332, -0.00001)
         B2 = _H(a, 3745.408911, -193.792705,  4.340858,  -0.376174, 0.004053)
         B4 = _H(a,   -0.734684,    0.144466, -0.011842)
-        B6 =          0.000488
-        X  = _H(b, B0, z, B2, z, B4, z, B6).fover(ab_M)  # 1,000 Km!
+        X  = _H(b, B0, z, B2, z, B4, z, 0.000488).fover(ab_M)  # 1,000 Km!
 
         t = self._ChLV9Tuple(True, M, n, Y, X, h_, lat, lon, h)
         if gamma:
@@ -1046,8 +1042,7 @@ class ChLVe(_ChLV, LocalCartesian):
         A0  = _H(b,  ChLV._sLat, 32386.4877666, -25.486822, -132.457771, 0.48747, 0.81305, -0.0069)
         A2  = _H(b, -2713.537919, -450.442705,  -75.53194,   -14.63049, -2.7604)
         A4  = _H(b,    24.42786,    13.20703,     4.7476)
-        A6  =          -0.4249
-        lat = _H(a, A0, z, A2, z, A4, z, A6).fover(s_d)
+        lat = _H(a, A0, z, A2, z, A4, z, -0.4249).fover(s_d)
 
         A1  = _H(b, 47297.3056722, 7925.714783, 1328.129667, 255.02202, 48.17474, 9.0243)
         A3  = _H(b,  -442.709889,  -255.02202,   -96.34947,  -30.0808)
@@ -1075,15 +1070,16 @@ def _fov_2(**fov):
 
 
 def _toLocal(inst, ltp, Xyz, Xyz_kwds):
-    '''(INTENRAL) Helper for C{CartesianBase.toLocal} and C{latLonBase.toLocal}.
+    '''(INTERNAL) Helper for C{CartesianBase.toAer}, C{CartesianBase.toEnu},
+       C{CartesianBase.toLocal}, C{CartesianBase.toNed} and C{latLonBase.toLocal}.
     '''
     return _xLtp(ltp, inst._Ltp)._ecef2local(inst._ecef9, Xyz, Xyz_kwds)
 
 
 def _toLtp(inst, Ecef, ecef9, name):
-    '''(INTENRAL) Helper for C{CartesianBase.toLtp} and C{latLonBase.toLtp}.
+    '''(INTERNAL) Helper for C{CartesianBase.toLtp}, C{ecef.toLtp} and C{latLonBase.toLtp}.
     '''
-    return inst._Ltp if Ecef in (None, inst.Ecef) and not name else \
+    return inst._Ltp if (not name) and Ecef in (None, inst.Ecef) else \
                  Ltp(ecef9, ecef=Ecef(inst.datum), name=inst._name__(name))
 
 
@@ -1125,7 +1121,7 @@ def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
 
 
 def _xLtp(ltp, *dflt):
-    '''(INTERNAL) Validate B{C{ltp}} or ist B{C{dflt}}.
+    '''(INTERNAL) Validate B{C{ltp}} if not C{None} else B{C{dflt}}.
     '''
     if dflt and ltp is None:
         ltp = dflt[0]
@@ -1134,7 +1130,7 @@ def _xLtp(ltp, *dflt):
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),