pygeodesy 24.6.1__py2.py3-none-any.whl → 24.6.24__py2.py3-none-any.whl

pygeodesy/utmups.py

@@ -31,7 +31,7 @@ from pygeodesy.utmupsBase import Fmt, _to4lldn, _to3zBhp, _UPS_ZONE, \
                                 _UTMUPS_ZONE_MAX, _WGS84
 
 __all__ = _ALL_LAZY.utmups
-__version__ = '24.05.30'
+__version__ = '24.06.11'
 
 _MGRS_TILE = _100km  # in .mgrs.Mgrs.tile
 
@@ -111,32 +111,31 @@ def toUtmUps8(latlon, lon=None, datum=None, falsed=True, Utm=Utm, Ups=Ups,
 
        @arg latlon: Latitude (C{degrees}) or an (ellipsoidal)
                     geodetic C{LatLon} point.
-       @kwarg lon: Optional longitude (C{degrees}) or C{None}.
-       @kwarg datum: Optional datum to use this UTM coordinate,
-                     overriding B{C{latlon}}'s datum (C{Datum}).
-       @kwarg falsed: False both easting and northing (C{bool}).
-       @kwarg Utm: Optional class to return the UTM coordinate (L{Utm})
-                   or C{None}.
-       @kwarg Ups: Optional class to return the UPS coordinate (L{Ups})
-                   or C{None}.
-       @kwarg pole: Optional top/center of UPS (stereographic)
-                    projection (C{str}, C{'N[orth]'} or C{'S[outh]'}).
-       @kwarg name_cmoff: Optional B{C{Utm}} or B{C{Ups}} C{B{name}=NN}
-                   (C{str}) and DEPRECATED keyword argument C{B{cmoff}=True}
-                   to offset the longitude from the zone's central meridian
-                   (C{bool}), use B{C{falsed}} instead and I{for UTM only}.
-
-       @return: The UTM or UPS coordinate (B{C{Utm}} respectively B{C{Ups}})
-                or a L{UtmUps8Tuple}C{(zone, hemipole, easting, northing,
-                band, datum, gamma, scale)} if B{C{Utm}} respectively
-                B{C{Ups}} is C{None} or B{C{cmoff}} is C{False}.
-
-       @raise RangeError: If B{C{lat}} outside the valid UTM or UPS bands
-                          or if B{C{lat}} or B{C{lon}} outside the valid
-                          range and L{pygeodesy.rangerrors} set to C{True}.
-
-       @raise TypeError: If B{C{latlon}} is not ellipsoidal or B{C{lon}}
-                         value is missing of B{C{datum}} is invalid.
+       @kwarg lon: Longitude (C{degrees}), required if B{C{latlon}} is C{degrees},
+                   ignored otherwise.
+       @kwarg datum: Optional datum to use this UTM coordinate, overriding the
+                     B{C{latlon}}'s datum (C{Datum}).
+       @kwarg falsed: If C{True}, false both easting and northing (C{bool}).
+       @kwarg Utm: Optional class to return the UTM coordinate (L{Utm}) or C{None}.
+       @kwarg Ups: Optional class to return the UPS coordinate (L{Ups}) or C{None}.
+       @kwarg pole: Optional top/center of UPS (stereographic) projection (C{str},
+                    C{'N[orth]'} or C{'S[outh]'}).
+       @kwarg name_cmoff: Optional C{B{name}=NN} (C{str}) and DEPRECATED keyword
+                   argument C{B{cmoff}=True} to offset the longitude from the zone's
+                   central meridian (C{bool}), use B{C{falsed}} instead and I{for
+                   UTM only}.
+
+       @return: The UTM or UPS coordinate (B{C{Utm}} respectively B{C{Ups}}) or a
+                L{UtmUps8Tuple}C{(zone, hemipole, easting, northing, band, datum,
+                gamma, scale)} if B{C{Utm}} respectively C{B{Ups} is None} or if
+                C{B{falsed} is False}.
+
+       @raise RangeError: If B{C{lat}} outside the valid UTM or UPS bands or if
+                          B{C{lat}} or B{C{lon}} outside the valid range and
+                          L{rangerrors<pygeodesy.rangerrors>} is C{True}.
+
+       @raise TypeError: If B{C{latlon}} is not ellipsoidal or B{C{lon}} is missing
+                         or B{C{datum}} is invalid.
 
        @raise UTMUPSError: UTM or UPS validation failed.
 
@@ -154,21 +153,20 @@ def toUtmUps8(latlon, lon=None, datum=None, falsed=True, Utm=Utm, Ups=Ups,
     return u
 
 
-def UtmUps(zone, hemipole, easting, northing, band=NN, datum=_WGS84,
-                                              falsed=True, **name):
+def UtmUps(zone, hemipole, easting, northing, band=NN, datum=_WGS84, falsed=True, **name):
     '''Class-like function to create a UTM/UPS coordinate.
 
        @kwarg zone: The UTM zone with/-out I{longitudinal} Band or UPS zone C{0}
                     or C{"00"} with/-out I{polar} Band (C{str} or C{int}).
-       @kwarg hemipole: UTM hemisphere or UPS top/center of projection
-                        (C{str}, C{'N[orth]'} or C{'S[outh]'}).
+       @kwarg hemipole: UTM hemisphere or UPS top/center of projection (C{str},
+                        C{'N[orth]'} or C{'S[outh]'}).
        @arg easting: Easting, see B{C{falsed}} (C{meter}).
        @arg northing: Northing, see B{C{falsed}} (C{meter}).
        @kwarg band: Optional, UTM I{latitudinal} C{'C'|'D'|..|'W'|'X'} or UPS
                     I{polar} Band letter C{'A'|'B'|'Y'|'Z'} Band letter (C{str}).
        @kwarg datum: The coordinate's datum (L{Datum}).
-       @kwarg falsed: If C{True}, both B{C{easting}} and B{C{northing}} are
-                      falsed (C{bool}).
+       @kwarg falsed: If C{True}, both B{C{easting}} and B{C{northing}} are falsed
+                      (C{bool}).
        @kwarg name: Optional L{Utm} or L{Ups} C{B{name}=NN} (C{str}).
 
        @return: New UTM or UPS instance (L{Utm} or L{Ups}).
@@ -182,17 +180,16 @@ def UtmUps(zone, hemipole, easting, northing, band=NN, datum=_WGS84,
     '''
     z, B, hp = _to3zBhp(zone, band, hemipole=hemipole)
     U = Ups if z in (_UPS_ZONE, _UPS_ZONE_STR) else Utm
-    return U(z, hp, easting, northing, band=B, datum=datum,
-                                       falsed=falsed, **name)
+    return U(z, hp, easting, northing, band=B, datum=datum, falsed=falsed, **name)
 
 
 def utmupsValidate(coord, falsed=False, MGRS=False, Error=UTMUPSError):
     '''Check a UTM or UPS coordinate.
 
-       @arg coord: The UTM or UPS coordinate (L{Utm}, L{Etm}, L{Ups}
-                   or C{5+Tuple}).
-       @kwarg falsed: C{5+Tuple} easting and northing are falsed
-                      (C{bool}), ignored otherwise.
+       @arg coord: The UTM or UPS coordinate (L{Utm}, L{Etm}, L{Ups} or
+                   C{5+Tuple}).
+       @kwarg falsed: If C{True}, easting and northing are falsed in the
+                      C{B{coord} 5+Tuple} (C{bool}), ignored otherwise.
        @kwarg MGRS: Increase easting and northing ranges (C{bool}).
        @kwarg Error: Optional error to raise, overriding the default
                      (L{UTMUPSError}).
@@ -253,8 +250,8 @@ def utmupsValidateOK(coord, falsed=False, ok=True):
     '''Check a UTM or UPS coordinate.
 
        @arg coord: The UTM or UPS coordinate (L{Utm}, L{Ups} or C{5+Tuple}).
-       @kwarg falsed: Use C{B{falsed}=True} if the C{5+Tuple} easting and
-                      northing are falsed (C{bool}).
+       @kwarg falsed: If C{True}, easting and northing are falsed in the
+                      C{B{coord} 5+Tuple} (C{bool}), ignored otherwise.
        @kwarg ok: Result to return if validation passed (B{C{ok}}).
 
        @return: B{C{ok}} if validation passed, otherwise the L{UTMUPSError}.
@@ -263,9 +260,9 @@ def utmupsValidateOK(coord, falsed=False, ok=True):
     '''
     try:
         utmupsValidate(coord, falsed=falsed)
-        return ok
     except UTMUPSError as x:
         return x
+    return ok
 
 
 def utmupsZoneBand5(lat, lon, cmoff=False, **name):
@@ -280,11 +277,11 @@ def utmupsZoneBand5(lat, lon, cmoff=False, **name):
 
        @return: A L{UtmUpsLatLon5Tuple}C{(zone, band, hemipole, lat, lon)}
                 where C{hemipole} is C{'N'|'S'}, the UTM hemisphere or UPS
-                pole, the UPS projection top/center.
+                pole, projection top/center.
 
-       @raise RangeError: If B{C{lat}} outside the valid UTM or UPS bands
-                          or if B{C{lat}} or B{C{lon}} outside the valid
-                          range and L{pygeodesy.rangerrors} set to C{True}.
+       @raise RangeError: If B{C{lat}} outside the valid UTM or UPS bands or
+                          if B{C{lat}} or B{C{lon}} outside the valid range
+                          and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @raise ValueError: Invalid B{C{lat}} or B{C{lon}}.
 

pygeodesy/utmupsBase.py

@@ -12,22 +12,22 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.dms import degDMS, parseDMS2
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB
 from pygeodesy.errors import _or, ParseError, _parseX, _ValueError, \
-                             _xkwds, _xkwds_not
+                             _xattrs, _xkwds, _xkwds_not
 # from pygeodesy.internals import _name__, _under  # from .named
 from pygeodesy.interns import NN, _A_, _B_, _COMMA_, _Error_, \
                              _gamma_, _n_a_, _not_, _N_, _NS_, _PLUS_, \
                              _S_, _scale_, _SPACE_, _Y_, _Z_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedBase, _xnamed,  _name__, _under
+from pygeodesy.named import _name__, _NamedBase,  _under
 from pygeodesy.namedTuples import EasNor2Tuple, LatLonDatum5Tuple
 from pygeodesy.props import deprecated_method, property_doc_, _update_all, \
                             deprecated_property_RO, Property_RO, property_RO
-from pygeodesy.streprs import Fmt, fstr, _fstrENH2, _xattrs, _xzipairs
+from pygeodesy.streprs import Fmt, fstr, _fstrENH2, _xzipairs
 from pygeodesy.units import Band, Easting, Northing, Scalar, Zone
 from pygeodesy.utily import _Wrap, wrap360
 
 __all__ = _ALL_LAZY.utmupsBase
-__version__ = '24.05.30'
+__version__ = '24.06.12'
 
 _UPS_BANDS = _A_, _B_, _Y_, _Z_  # UPS polar bands SE, SW, NE, NW
 # _UTM_BANDS = _MODS.utm._Bands
@@ -210,13 +210,12 @@ class UtmUpsBase(_NamedBase):
         ll = self._latlon
         if LatLon is None:
             r = LatLonDatum5Tuple(ll.lat, ll.lon, ll.datum,
-                                  ll.gamma, ll.scale)
+                                  ll.gamma, ll.scale, name=ll.name)
         else:
             _xsubclassof(_LLEB, LatLon=LatLon)
-            kwds = _xkwds(LatLon_kwds, datum=ll.datum)
-            r = _xattrs(LatLon(ll.lat, ll.lon, **kwds),
-                               ll, _under(_gamma_), _under(_scale_))
-        return _xnamed(r, ll.name)
+            r =  LatLon(ll.lat, ll.lon, **_xkwds(LatLon_kwds, datum=ll.datum, name=ll.name))
+            r = _xattrs(r, ll, _under(_gamma_), _under(_scale_))
+        return r
 
     def _latlon5args(self, ll, g, k, _toBand, unfalse, *other):
         '''(INTERNAL) See C{._toLLEB} methods, functions C{ups.toUps8} and C{utm._toXtm8}
@@ -472,7 +471,7 @@ def _to3zBhp(zone, band, hemipole=NN, Error=_ValueError):  # in .epsg, .ups, .ut
                 elif not B:
                     return z, B, hp
 
-        raise ValueError  # _invalid_
+        raise ValueError()  # _invalid_
     except (AttributeError, IndexError, TypeError, ValueError) as x:
         raise Error(zone=zone, band=B, hemipole=hemipole, cause=x)
 

pygeodesy/vector3d.py

@@ -25,13 +25,15 @@ from pygeodesy.namedTuples import Intersection3Tuple, NearestOn2Tuple, \
 # from pygeodesy.streprs import Fmt  # from .iters
 from pygeodesy.units import _fi_j2, _isDegrees, Radius, Radius_
 from pygeodesy.utily import atan2b, sincos2d
-# from pygeodesy.vector2d import ....  # in .... below
+# import pygeodesy.vector2d as _vector2d  # _MODS.into
 from pygeodesy.vector3dBase import Vector3dBase
 
 # from math import fabs, sqrt  # from .fmath
 
 __all__ = _ALL_LAZY.vector3d
-__version__ = '24.05.21'
+__version__ = '24.06.18'
+
+_vector2d = _MODS.into(vector2d=__name__)
 
 
 class Vector3d(Vector3dBase):
@@ -87,7 +89,7 @@ class Vector3d(Vector3dBase):
                  Triangle<https://MathWorld.Wolfram.com/ContactTriangle.html>}.
         '''
         try:
-            return _MODS.vector2d._circin6(self, point2, point3, eps=eps, useZ=True)
+            return _vector2d._circin6(self, point2, point3, eps=eps, useZ=True)
         except (AssertionError, TypeError, ValueError) as x:
             raise _xError(x, point=self, point2=point2, point3=point3)
 
@@ -118,8 +120,8 @@ class Vector3d(Vector3dBase):
            @see: Function L{pygeodesy.circum3} and methods L{circum4_} and L{meeus2}.
         '''
         try:
-            return _MODS.vector2d._circum3(self, point2, point3, circum=circum,
-                                                 eps=eps, useZ=True, clas=self.classof)
+            return _vector2d._circum3(self, point2, point3, circum=circum,
+                                            eps=eps, useZ=True, clas=self.classof)
         except (AssertionError, TypeError, ValueError) as x:
             raise _xError(x, point=self, point2=point2, point3=point3, circum=circum)
 
@@ -143,7 +145,7 @@ class Vector3d(Vector3dBase):
 
            @see: Function L{pygeodesy.circum4_} and methods L{circum3} and L{meeus2}.
         '''
-        return _MODS.vector2d.circum4_(self, *points, useZ=True, Vector=self.classof)
+        return _vector2d.circum4_(self, *points, useZ=True, Vector=self.classof)
 
     def iscolinearWith(self, point1, point2, eps=EPS):
         '''Check whether this and two other (3-D) points are colinear.
@@ -163,7 +165,7 @@ class Vector3d(Vector3dBase):
            @see: Method L{nearestOn}.
         '''
         v = self if self.name else _otherV3d(NN_OK=False, this=self)
-        return _MODS.vector2d._iscolinearWith(v, point1, point2, eps=eps)
+        return _vector2d._iscolinearWith(v, point1, point2, eps=eps)
 
     def meeus2(self, point2, point3, circum=False):
         '''Return the radius and I{Meeus}' Type of the smallest circle I{through}
@@ -186,7 +188,7 @@ class Vector3d(Vector3dBase):
            @see: Function L{pygeodesy.meeus2} and methods L{circum3} and L{circum4_}.
         '''
         try:
-            return _MODS.vector2d._meeus2(self, point2, point3, circum, clas=self.classof)
+            return _vector2d._meeus2(self, point2, point3, circum, clas=self.classof)
         except (TypeError, ValueError) as x:
             raise _xError(x, point=self, point2=point2, point3=point3, circum=circum)
 
@@ -270,7 +272,7 @@ class Vector3d(Vector3dBase):
                  Circles<https://MathWorld.Wolfram.com/TangentCircles.html>}.
         '''
         try:
-            return _MODS.vector2d._radii11ABC(self, point2, point3, useZ=True)[0]
+            return _vector2d._radii11ABC(self, point2, point3, useZ=True)[0]
         except (TypeError, ValueError) as x:
             raise _xError(x, point=self, point2=point2, point3=point3)
 
@@ -299,7 +301,7 @@ class Vector3d(Vector3dBase):
 
            @see: Function L{pygeodesy.soddy4}.
         '''
-        return _MODS.vector2d.soddy4(self, point2, point3, eps=eps, useZ=True)
+        return _vector2d.soddy4(self, point2, point3, eps=eps, useZ=True)
 
     def trilaterate2d2(self, radius, center2, radius2, center3, radius3, eps=EPS4, z=INT0):
         '''Trilaterate this and two other circles, each given as a (2-D) center
@@ -335,10 +337,10 @@ class Vector3d(Vector3dBase):
             return v.x, v.y, r
 
         try:
-            return _MODS.vector2d._trilaterate2d2(*(_xyr3(radius,  center=self) +
-                                                    _xyr3(radius2, center2=center2) +
-                                                    _xyr3(radius3, center3=center3)),
-                                                     eps=eps, Vector=self.classof, z=z)
+            return _vector2d._trilaterate2d2(*(_xyr3(radius,  center=self) +
+                                               _xyr3(radius2, center2=center2) +
+                                               _xyr3(radius3, center3=center3)),
+                                               eps=eps, Vector=self.classof, z=z)
         except (AssertionError, TypeError, ValueError) as x:
             raise _xError(x, center=self,     radius=radius,
                              center2=center2, radius2=radius2,
@@ -386,10 +388,10 @@ class Vector3d(Vector3dBase):
         '''
         try:
             c1 = _otherV3d(center=self, NN_OK=False)
-            return _MODS.vector2d._trilaterate3d2(c1, Radius_(radius, low=eps),
-                                             center2, radius2,
-                                             center3, radius3,
-                                             eps=eps, clas=self.classof)
+            return _vector2d._trilaterate3d2(c1, Radius_(radius, low=eps),
+                                        center2, radius2,
+                                        center3, radius3,
+                                        eps=eps, clas=self.classof)
         except (AssertionError, TypeError, ValueError) as x:
             raise _xError(x, center=self,     radius=radius,
                              center2=center2, radius2=radius2,
@@ -473,7 +475,8 @@ def _intersect3d3(start1, end1, start2, end2, eps=EPS, useZ=False):  # MCCABE 16
     t  = cb.dot(ab)
     o1 = 0 if b1 else _outside(t, ab2, 1)
     v  = s1.plus(a.times(t / ab2))
-    o2 = 0 if b2 else _outside(v.minus(s2).dot(b), b.length2, 2)
+    t  = v.minus(s2).dot(b)
+    o2 = 0 if b2 else _outside(t, b.length2, 2)
     return v, o1, o2
 
 
@@ -539,16 +542,15 @@ def intersections2(center1, radius1, center2, radius2, sphere=True, **Vector_and
                                intersection points and optional, additional B{C{Vector}}
                                keyword arguments, otherwise B{C{center1}}'s (sub-)class.
 
-       @return: If B{C{sphere}} is C{True}, a 2-tuple of the C{center} and C{radius}
-                of the intersection of the I{spheres}.  The C{radius} is C{0.0} for
-                abutting spheres (and the C{center} is aka the I{radical center}).
+       @return: If C{B{sphere} is True}, a 2-tuple of the C{center} and C{radius} of the
+                intersection of the I{spheres}.  For abutting circles, C{radius} is C{0.0}
+                and C{center} is the I{radical center}.
 
-                If B{C{sphere}} is C{False}, a 2-tuple with the two intersection
-                points of the I{circles}.  For abutting circles, both points are
-                the same instance, aka the I{radical center}.
+                If C{B{sphere} is False}, a 2-tuple with the two intersection points of the
+                I{circles}.  For abutting circles, both points are the same instance, aka
+                the I{radical center}.
 
-       @raise IntersectionError: Concentric, invalid or non-intersecting spheres
-                                 or circles.
+       @raise IntersectionError: Concentric, invalid or non-intersecting spheres or circles.
 
        @raise TypeError: Invalid B{C{center1}} or B{C{center2}}.
 
@@ -635,15 +637,15 @@ def iscolinearWith(point, point1, point2, eps=EPS, useZ=True):
        @kwarg eps: Tolerance (C{scalar}), same units as C{x}, C{y} and C{z}.
        @kwarg useZ: If C{True}, use the Z components, otherwise force C{z=INT0} (C{bool}).
 
-       @return: C{True} if B{C{point}} is colinear B{C{point1}} and B{C{point2}},
-                        C{False} otherwise.
+       @return: C{True} if B{C{point}} is colinear B{C{point1}} and B{C{point2}}, C{False}
+                otherwise.
 
        @raise TypeError: Invalid B{C{point}}, B{C{point1}} or B{C{point2}}.
 
        @see: Function L{nearestOn}.
     '''
     p = _otherV3d(useZ=useZ, point=point)
-    return _MODS.vector2d._iscolinearWith(p, point1, point2, eps=eps, useZ=useZ)
+    return _vector2d._iscolinearWith(p, point1, point2, eps=eps, useZ=useZ)
 
 
 def nearestOn(point, point1, point2, within=True, useZ=True, Vector=None, **Vector_kwds):
@@ -659,8 +661,8 @@ def nearestOn(point, point1, point2, within=True, useZ=True, Vector=None, **Vect
                       points, otherwise the closest point on the extended line
                       through both points (C{bool}).
        @kwarg useZ: If C{True}, use the Z components, otherwise force C{z=INT0} (C{bool}).
-       @kwarg Vector: Class to return closest point (C{Cartesian}, L{Vector3d}
-                      or C{Vector3Tuple}) or C{None}.
+       @kwarg Vector: Class to return closest point (C{Cartesian}, L{Vector3d} or
+                      C{Vector3Tuple}) or C{None}.
        @kwarg Vector_kwds: Optional, additional B{C{Vector}} keyword arguments,
                            ignored if C{B{Vector} is None}.
 
@@ -764,23 +766,22 @@ def nearestOn6(point, points, closed=False, useZ=True, **Vector_and_kwds):  # ep
     return NearestOn6Tuple(v, sqrt(c2), f, j, s, e)
 
 
-def _nVc(v, clas=None, Vector=None, **Vector_kwds_name):  # in .vector2d
+def _nVc(v, clas=None, Vector=None, **name_Vector_kwds):  # in .vector2d
     # return a named C{Vector} or C{clas} instance
-    name, Vector_kwds = _name2__(**Vector_kwds_name)
+    name, kwds = _name2__(**name_Vector_kwds)
     if Vector is not None:
-        v = Vector(v.x, v.y, v.z, **Vector_kwds)
+        v = Vector(v.x, v.y, v.z, **kwds)
     elif clas is not None:
         v = clas(v.x, v.y, v.z)  # ignore Vector_kwds
     return _xnamed(v, name) if name else v
 
 
-def _otherV3d(useZ=True, NN_OK=True, i=None, **name_v):
+def _otherV3d(useZ=True, NN_OK=True, i=None, **name_vector):
     # check named vector instance, return Vector3d
-    n, v = _xkwds_item2(name_v)
+    n, v = _xkwds_item2(name_vector)
+    n    =  Fmt.INDEX(n, i)
     if useZ and isinstance(v, Vector3dBase):
-        return v if NN_OK or v.name else v.copy(name=Fmt.INDEX(n, i))
-
-    n = Fmt.INDEX(n, i)
+        return v if NN_OK or v.name else v.copy(name=n)
     try:
         return Vector3d(v.x, v.y, (v.z if useZ else INT0), name=n)
     except AttributeError:  # no .x, .y or .z attr
@@ -797,7 +798,7 @@ def parse3d(str3d, sep=_COMMA_, Vector=Vector3d, **Vector_kwds):
        @kwarg Vector_kwds: Optional B{C{Vector}} keyword arguments,
                            ignored if C{B{Vector} is None}.
 
-       @return: A B{C{Vector}} instance or if B{C{Vector}} is C{None},
+       @return: A B{C{Vector}} instance or if C{B{Vector} is None},
                 a named L{Vector3Tuple}C{(x, y, z)}.
 
        @raise VectorError: Invalid B{C{str3d}}.
@@ -818,11 +819,11 @@ def sumOf(vectors, Vector=Vector3d, **Vector_kwds):
 
        @arg vectors: Vectors to be added (L{Vector3d}[]).
        @kwarg Vector: Optional class for the vectorial sum (L{Vector3d}).
-       @kwarg Vector_kwds: Optional B{C{Vector}} keyword arguments,
-                           ignored if C{B{Vector} is None}.
+       @kwarg Vector_kwds: Optional B{C{Vector}} keyword arguments, ignored
+                           if C{B{Vector} is None}.
 
-       @return: Vectorial sum as B{C{Vector}} or if B{C{Vector}} is
-                C{None}, a named L{Vector3Tuple}C{(x, y, z)}.
+       @return: Vectorial sum as B{C{Vector}} or if B{C{Vector} is None},
+                a named L{Vector3Tuple}C{(x, y, z)}.
 
        @raise VectorError: No B{C{vectors}}.
     '''
@@ -869,9 +870,9 @@ def trilaterate2d2(x1, y1, radius1, x2, y2, radius2, x3, y3, radius3,
              <https://math.StackExchange.com/questions/884807>} and function
              L{pygeodesy.trilaterate3d2}.
     '''
-    return _MODS.vector2d._trilaterate2d2(x1, y1, radius1,
-                                          x2, y2, radius2,
-                                          x3, y3, radius3, eps=eps, **Vector_and_kwds)
+    return _vector2d._trilaterate2d2(x1, y1, radius1,
+                                     x2, y2, radius2,
+                                     x3, y3, radius3, eps=eps, **Vector_and_kwds)
 
 
 def trilaterate3d2(center1, radius1, center2, radius2, center3, radius3,
@@ -919,27 +920,23 @@ def trilaterate3d2(center1, radius1, center2, radius2, center3, radius3,
              288825016>} and function L{pygeodesy.trilaterate2d2}.
     '''
     try:
-        return _MODS.vector2d._trilaterate3d2(_otherV3d(center1=center1, NN_OK=False),
-                                               Radius_(radius1=radius1, low=eps),
-                                               center2, radius2, center3, radius3, eps=eps,
-                                               clas=center1.classof, **Vector_and_kwds)
+        return _vector2d._trilaterate3d2(_otherV3d(center1=center1, NN_OK=False),
+                                           Radius_(radius1=radius1, low=eps),
+                                           center2, radius2, center3, radius3, eps=eps,
+                                           clas=center1.classof, **Vector_and_kwds)
     except (AssertionError, TypeError, ValueError) as x:
         raise _xError(x, center1=center1, radius1=radius1,
                          center2=center2, radius2=radius2,
                          center3=center3, radius3=radius3)
 
 
-def _xyzhdn3(xyz, height, datum, ll, **name):  # in .cartesianBase, .nvectorBase
-    '''(INTERNAL) Get a C{(h, d, name)} 3-tuple.
+def _xyzhdlln4(xyz, height, datum, ll=None, **name):  # in .cartesianBase, .nvectorBase
+    '''(INTERNAL) Get a C{(h, d, ll, name)} 4-tuple.
     '''
-    h = height or _xattr(xyz, height=None) \
-               or _xattr(xyz, h=None) \
-               or _xattr(ll,  height=None)
-
-    d = datum or _xattr(xyz, datum=None) \
-              or _xattr(ll,  datum=None)
-
-    return h, d, _name__(name, _or_nameof=xyz)
+    _x = _xattr
+    h  =  height or _x(xyz, height=None) or _x(xyz, h=None) or _x(ll, height=None)
+    d  =  datum  or _x(xyz, datum=None)  or _x(ll,  datum=None)
+    return h, d, ll, _name__(name, _or_nameof=ll)
 
 
 __all__ += _ALL_DOCS(intersections2, sumOf, Vector3dBase)

pygeodesy/vector3dBase.py

@@ -9,7 +9,7 @@ A pure Python implementation of vector-based functions by I{(C) Chris Veness
 '''
 
 from pygeodesy.basics import _copysign, islistuple, isscalar, map1, \
-                              map2, _zip
+                              map2, _signOf, _zip
 from pygeodesy.constants import EPS, EPS0, INT0, PI, PI2, _copysignINF, \
                                _float0, isnear0, isnear1, isneg0, \
                                _pos_self, _0_0, _1_0
@@ -30,7 +30,7 @@ from pygeodesy.units import Float, Scalar
 from math import atan2, ceil, fabs, floor, trunc
 
 __all__ = _ALL_LAZY.vector3dBase
-__version__ = '24.05.19'
+__version__ = '24.06.11'
 
 
 class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
@@ -107,9 +107,7 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
 
            @raise TypeError: Incompatible B{C{other}} C{type}.
         '''
-        n = self.others(other).length
-        return -1 if self.length < n else (
-               +1 if self.length > n else 0)
+        return _signOf(self.length, self._other_cmp(other))
 
     cmp = __cmp__
 
@@ -156,7 +154,7 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
 
            @raise TypeError: Incompatible B{C{other}} C{type}.
         '''
-        return self.length >= self.others(other).length
+        return self.length >= self._other_cmp(other)
 
 #   def __getitem__(self, key):
 #       '''Return C{item} at index or slice C{[B{key}]}.
@@ -172,7 +170,7 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
 
            @raise TypeError: Incompatible B{C{other}} C{type}.
         '''
-        return self.length > self.others(other).length
+        return self.length > self._other_cmp(other)
 
     def __hash__(self):  # PYCHOK no cover
         '''Return this instance' C{hash}.
@@ -261,7 +259,7 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
 
            @raise TypeError: Incompatible B{C{other}} C{type}.
         '''
-        return self.length <= self.others(other).length
+        return self.length <= self._other_cmp(other)
 
 #   def __len__(self):
 #       '''Return C{3}, always.
@@ -277,7 +275,7 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
 
            @raise TypeError: Incompatible B{C{other}} C{type}.
         '''
-        return self.length < self.others(other).length
+        return self.length < self._other_cmp(other)
 
     def __matmul__(self, other):  # PYCHOK Python 3.5+
         '''Compute the cross product of this and an other vector, C{this @ B{other}}.
@@ -493,15 +491,14 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
         '''Compute the cross product of this and an other vector.
 
            @arg other: The other vector (L{Vector3d}).
-           @kwarg raiser: Optional, L{CrossError} label if raised (C{str},
-                          non-L{NN}).
-           @kwarg eps0: Near-zero tolerance (C{scalar}), same units as
-                        C{x}, C{y}, and C{z}.
+           @kwarg raiser: Optional, L{CrossError} label if raised (C{str}, non-L{NN}).
+           @kwarg eps0: Near-zero tolerance (C{scalar}), same units as C{x}, C{y} and
+                        C{z}.
 
            @return: Cross product (L{Vector3d}).
 
-           @raise CrossError: Zero or near-zero cross product and both
-                              B{C{raiser}} and L{pygeodesy.crosserrors} set.
+           @raise CrossError: Zero or near-zero cross product and if B{C{raiser}} and
+                              L{crosserrors<pygeodesy.crosserrors>} are both C{True}.
 
            @raise TypeError: Incompatible B{C{other}} C{type}.
         '''
@@ -759,6 +756,11 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
         '''
         return _MODS.nvectorBase._N_vector_(*self.xyz, name=self.name)
 
+    def _other_cmp(self, other):
+        '''(INTERNAL) Return the value for comparison.
+        '''
+        return other if isscalar(other) else self.others(other).length
+
     def others(self, *other, **name_other_up):
         '''Refined class comparison.
 

pygeodesy/webmercator.py

@@ -36,7 +36,7 @@ from pygeodesy.utily import degrees90, degrees180
 from math import atan, atanh, exp, radians, sin, tanh
 
 __all__ = _ALL_LAZY.webmercator
-__version__ = '24.05.31'
+__version__ = '24.06.11'
 
 # _FalseEasting  = 0   # false Easting (C{meter})
 # _FalseNorthing = 0   # false Northing (C{meter})
@@ -283,8 +283,8 @@ def parseWM(strWM, radius=R_MA, Wm=Wm, **name):
                   or C{None}.
        @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-       @return: The WM coordinate (B{C{Wm}}) or if B{C{Wm}} is C{None}
-                an L{EasNorRadius3Tuple}C{(easting, northing, radius)}.
+       @return: The WM coordinate (B{C{Wm}}) or if C{B{Wm} is None}, an
+                L{EasNorRadius3Tuple}C{(easting, northing, radius)}.
 
        @raise WebMercatorError: Invalid B{C{strWM}}.
     '''
@@ -307,27 +307,25 @@ def parseWM(strWM, radius=R_MA, Wm=Wm, **name):
 def toWm(latlon, lon=None, earth=R_MA, Wm=Wm, **name_Wm_kwds_radius):
     '''Convert a lat-/longitude point to a WM coordinate.
 
-       @arg latlon: Latitude (C{degrees}) or an (ellipsoidal or
-                    spherical) geodetic C{LatLon} point.
+       @arg latlon: Latitude (C{degrees}) or an (ellipsoidal or spherical)
+                    geodetic C{LatLon} point.
        @kwarg lon: Optional longitude (C{degrees} or C{None}).
-       @kwarg earth: Earth radius (C{meter}), datum or ellipsoid
-                     (L{Datum}, L{a_f2Tuple}, L{Ellipsoid} or
-                     L{Ellipsoid2}), overridden by B{C{latlon}}'s
-                     datum if present.
-       @kwarg Wm: Optional class to return the WM coordinate (L{Wm})
-                  or C{None}.
-       @kwarg name_Wm_kwds_radius: Optional C{B{name}=NN} (C{str}),
-                   optional, additional B{C{Wm}} keyword arguments,
-                   ignored if C{B{Wm} is None} and DEPRECATED keyword
-                   argument C{B{radius}=earth}, use B{C{earth}}.
-
-       @return: The WM coordinate (B{C{Wm}}) or if B{C{Wm}} is C{None} an
+       @kwarg earth: Earth radius (C{meter}), datum or ellipsoid (L{Datum},
+                     L{a_f2Tuple}, L{Ellipsoid} or L{Ellipsoid2}), overridden
+                     by B{C{latlon}}'s datum if present.
+       @kwarg Wm: Optional class to return the WM coordinate (L{Wm}) or C{None}.
+       @kwarg name_Wm_kwds_radius: Optional C{B{name}=NN} (C{str}), optional,
+                   additional B{C{Wm}} keyword arguments, ignored if C{B{Wm} is
+                   None} and DEPRECATED keyword argument C{B{radius}=earth},
+                   use B{C{earth}}.
+
+       @return: The WM coordinate (B{C{Wm}}) or if C{B{Wm} is None}, an
                 L{EasNorRadius3Tuple}C{(easting, northing, radius)}.
 
-       @raise ValueError: If B{C{lon}} value is missing, if B{C{latlon}} is not
-                          scalar, if B{C{latlon}} is beyond the valid WM range
-                          and L{pygeodesy.rangerrors} is set to C{True} or if
-                          B{C{earth}} is invalid.
+       @raise ValueError: If B{C{earth}} is invalid, if B{C{lon}} value is missing,
+                          if B{C{latlon}} is not scalar, or if B{C{latlon}} is beyond
+                          the valid WM range and L{rangerrrors<pygeodesy.rangerrors>}
+                          is C{True}.
     '''
     name, kwds = _name2__(name_Wm_kwds_radius)
     R, kwds = _xkwds_pop2(kwds, radius=earth)