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

pygeodesy/lazily.py

@@ -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+
@@ -174,8 +174,8 @@ _ALL_INIT = _a(_pygeodesy_abspath_, _version_)
 # __all__ value for most modules, accessible as _ALL_LAZY.<module>
 _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                          albers=_a('AlbersEqualArea', 'AlbersEqualArea2', 'AlbersEqualArea4',
-                                    'AlbersEqualAreaCylindrical', 'AlbersEqualAreaNorth', 'AlbersEqualAreaSouth',
-                                    'AlbersError', 'Albers7Tuple'),
+                                   'AlbersEqualAreaCylindrical', 'AlbersEqualAreaNorth', 'AlbersEqualAreaSouth',
+                                   'AlbersError', 'Albers7Tuple'),
                        auxilats=_a(),  # module only
                       azimuthal=_a('AzimuthalError', 'Azimuthal7Tuple',
                                    'Equidistant', 'EquidistantExact', 'EquidistantGeodSolve', 'EquidistantKarney',
@@ -241,12 +241,12 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                           fmath=_a('Fdot', 'Fhorner', 'Fhypot', 'Fpolynomial', 'Fpowers', 'Fcbrt', 'Froot', 'Fsqrt',
                                    'bqrt', 'cbrt', 'cbrt2', 'euclid', 'euclid_',
                                    'facos1', 'fasin1', 'fatan', 'fatan1', 'fatan2', 'favg',
-                                   'fdot', 'fdot3', 'fma', 'fmean', 'fmean_', 'fhorner', 'fidw', 'f2mul_', 'fpolynomial',
-                                   'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder',
+                                   'fdot', 'fdot_', 'fdot3', 'fma', 'fmean', 'fmean_', 'fhorner', 'fidw', 'f2mul_',
+                                   'fpolynomial', 'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder',
                                    'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',
                                    'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'),
                           formy=_a('Radical2Tuple',
-                                   'antipode', 'antipode_', 'bearing', 'bearing_',
+                                   'angle2chord', 'antipode', 'antipode_', 'bearing', 'bearing_', 'chord2angle',
                                    'compassAngle', 'cosineForsytheAndoyerLambert', 'cosineForsytheAndoyerLambert_',
                                    'cosineAndoyerLambert', 'cosineAndoyerLambert_', 'cosineLaw', 'cosineLaw_',
                                    'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_',
@@ -255,8 +255,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    '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',
@@ -297,7 +296,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 +321,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 +343,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'),
@@ -373,7 +372,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    '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',
+                                   'tan', 'tan_', 'tand', 'tand_', 'tan_2', 'tanPI_2_2', 'toise2m', 'truncate',
                                    'unroll180', 'unrollPI',
                                    'wrap90', 'wrap180', 'wrap360', 'wrapPI_2', 'wrapPI', 'wrapPI2', 'wrap_normal',
                                    'yard2m'),
@@ -409,7 +408,8 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                                          '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 +511,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.10.15'
+__version__ = '24.11.28'
 
 
 def _ALL_OTHER(*objs):
@@ -899,7 +899,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

@@ -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)}.
@@ -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.08.18'
+__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):
@@ -150,16 +149,16 @@ 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)}.
 
            @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,10 +466,10 @@ 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 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 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}.
 
            @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,
@@ -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))
 
 
@@ -1098,9 +1094,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)}.
@@ -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"),