pygeodesy 24.5.24__py2.py3-none-any.whl → 24.6.9__py2.py3-none-any.whl

pygeodesy/utmupsBase.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 u'''(INTERNAL) Private class C{UtmUpsBase}, functions and constants
-for L{epsg}, L{etm}, L{mgrs}, L{ups} and L{utm}.
+for modules L{epsg}, L{etm}, L{mgrs}, L{ups} and L{utm}.
 '''
 
 from pygeodesy.basics import isint, isscalar, isstr, neg_, \
@@ -11,12 +11,12 @@ from pygeodesy.constants import _float, _0_0, _0_5, _N_90_0, _180_0
 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, _UnexpectedError, \
-                             _ValueError, _xkwds, _xkwds_not, _xkwds_pop2
+from pygeodesy.errors import _or, ParseError, _parseX, _ValueError, \
+                             _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_, \
-                             _scale_, _SPACE_, _Y_, _Z_
+                             _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.namedTuples import EasNor2Tuple, LatLonDatum5Tuple
@@ -27,7 +27,7 @@ from pygeodesy.units import Band, Easting, Northing, Scalar, Zone
 from pygeodesy.utily import _Wrap, wrap360
 
 __all__ = _ALL_LAZY.utmupsBase
-__version__ = '24.05.19'
+__version__ = '24.06.09'
 
 _UPS_BANDS = _A_, _B_, _Y_, _Z_  # UPS polar bands SE, SW, NE, NW
 # _UTM_BANDS = _MODS.utm._Bands
@@ -59,94 +59,6 @@ _UTMUPS_ZONE_MIN     = _UPS_ZONE      # PYCHOK for export too, by .units.py
 # _UTM                  = -2
 
 
-def _hemi(lat, N=0):  # imported by .ups, .utm
-    '''Return the hemisphere letter.
-
-       @arg lat: Latitude (C{degrees} or C{radians}).
-       @kwarg N: Minimal North latitude, C{0} or C{_N_}.
-
-       @return: C{'N'|'S'} for north-/southern hemisphere.
-    '''
-    return _NS_[int(lat < N)]
-
-
-def _to4lldn(latlon, lon, datum, name, wrap=False):
-    '''(INTERNAL) Return 4-tuple (C{lat, lon, datum, name}).
-    '''
-    try:
-        # if lon is not None:
-        #     raise AttributeError
-        lat, lon = float(latlon.lat), float(latlon.lon)
-        _xinstanceof(_LLEB, LatLonDatum5Tuple, latlon=latlon)
-        if wrap:
-            _Wrap.latlon(lat, lon)
-        d = datum or latlon.datum
-    except AttributeError:
-        lat, lon = _Wrap.latlonDMS2(latlon, lon) if wrap else \
-                          parseDMS2(latlon, lon)  # clipped
-        d = datum or _WGS84
-    return lat, lon, d, _name__(name, _or_nameof=latlon)
-
-
-def _to3zBhp(zone, band, hemipole=NN, Error=_ValueError):  # imported by .epsg, .ups, .utm, .utmups
-    '''Parse UTM/UPS zone, Band letter and hemisphere/pole letter.
-
-       @arg zone: Zone with/-out Band (C{scalar} or C{str}).
-       @kwarg band: Optional I{longitudinal/polar} Band letter (C{str}).
-       @kwarg hemipole: Optional hemisphere/pole letter (C{str}).
-       @kwarg Error: Optional error to raise, overriding the default
-                     C{ValueError}.
-
-       @return: 3-Tuple (C{zone, Band, hemisphere/pole}) as (C{int, str,
-                'N'|'S'}) where C{zone} is C{0} for UPS or C{1..60} for
-                UTM and C{Band} is C{'A'..'Z'} I{NOT} checked for valid
-                UTM/UPS bands.
-
-       @raise ValueError: Invalid B{C{zone}}, B{C{band}} or B{C{hemipole}}.
-    '''
-    try:
-        B, z = band, _UTMUPS_ZONE_INVALID
-        if isscalar(zone):
-            z = int(zone)
-        elif zone and isstr(zone):
-            if zone.isdigit():
-                z = int(zone)
-            elif len(zone) > 1:
-                B = zone[-1:]
-                z = int(zone[:-1])
-            elif zone.upper() in _UPS_BANDS:  # single letter
-                B =  zone
-                z = _UPS_ZONE
-
-        if _UTMUPS_ZONE_MIN <= z <= _UTMUPS_ZONE_MAX:
-            hp = hemipole[:1].upper()
-            if hp in _NS_ or not hp:
-                z = Zone(z)
-                B = Band(B.upper())
-                if B.isalpha():
-                    return z, B, (hp or _hemi(B, _N_))
-                elif not B:
-                    return z, B, hp
-
-        raise ValueError  # _invalid_
-    except (AttributeError, IndexError, TypeError, ValueError) as x:
-        raise Error(zone=zone, band=B, hemipole=hemipole, cause=x)
-
-
-def _to3zll(lat, lon):  # imported by .ups, .utm
-    '''Wrap lat- and longitude and determine UTM zone.
-
-       @arg lat: Latitude (C{degrees}).
-       @arg lon: Longitude (C{degrees}).
-
-       @return: 3-Tuple (C{zone, lat, lon}) as (C{int}, C{degrees90},
-                C{degrees180}) where C{zone} is C{1..60} for UTM.
-    '''
-    x = wrap360(lon + _180_0)  # use wrap360 to get ...
-    z = int(x) // 6 + 1  # ... longitudinal UTM zone [1, 60] and ...
-    return Zone(z), lat, (x - _180_0)  # ... -180 <= lon < 180
-
-
 class UtmUpsBase(_NamedBase):
     '''(INTERNAL) Base class for L{Utm} and L{Ups} coordinates.
     '''
@@ -166,7 +78,7 @@ class UtmUpsBase(_NamedBase):
     _utm        =  None   # cached toUtm (L{Utm})
 
     def __init__(self, easting, northing, band=NN, datum=None, falsed=True,
-                                          gamma=None, scale=None, **convergence):
+                                                   gamma=None, scale=None):
         '''(INTERNAL) New L{UtmUpsBase}.
         '''
         E = self._Error
@@ -185,10 +97,6 @@ class UtmUpsBase(_NamedBase):
         if not falsed:
             self._falsed = False
 
-        if convergence:  # for backward compatibility
-            gamma, kwds = _xkwds_pop2(convergence, convergence=gamma)
-            if kwds:
-                raise _UnexpectedError(**kwds)
         if gamma is not self._gamma:
             self._gamma = Scalar(gamma=gamma, Error=E)
         if scale is not self._scale:
@@ -272,7 +180,7 @@ class UtmUpsBase(_NamedBase):
 
     @Property_RO
     def falsed(self):
-        '''Get easting and northing falsed (C{bool}).
+        '''Are easting and northing falsed (C{bool})?
         '''
         return self._falsed
 
@@ -310,9 +218,11 @@ class UtmUpsBase(_NamedBase):
                                ll, _under(_gamma_), _under(_scale_))
         return _xnamed(r, ll.name)
 
-    def _latlon5args(self, ll, _toBand, unfalse, *other):
+    def _latlon5args(self, ll, g, k, _toBand, unfalse, *other):
         '''(INTERNAL) See C{._toLLEB} methods, functions C{ups.toUps8} and C{utm._toXtm8}
         '''
+        ll._gamma = g
+        ll._scale = k
         ll._toLLEB_args = (unfalse,) + other
         if unfalse:
             if not self._band:
@@ -418,17 +328,26 @@ class UtmUpsBase(_NamedBase):
         return t if sep is None else sep.join(t)
 
 
-def _lowerleft(utmups, center):  # by .ellipsoidalBase._lowerleft
+def _hemi(lat, N=0):  # in .ups, .utm
+    '''Return the hemisphere letter.
+
+       @arg lat: Latitude (C{degrees} or C{radians}).
+       @kwarg N: Minimal North latitude, C{0} or C{_N_}.
+
+       @return: C{'N'|'S'} for north-/southern hemisphere.
+    '''
+    return _S_ if lat < N else _N_
+
+
+def _lowerleft(utmups, center):  # in .ellipsoidalBase._lowerleft
     '''(INTERNAL) I{Un}-center a B{C{utmups}} to its C{lowerleft} by
        C{B{center} meter} or by a I{guess} if B{C{center}} is C{0}.
     '''
     if center:
         e = n = -center
     else:
-        c = 5  # center
-        for _ in range(3):
-            c *= 10  # 50, 500, 5000
-            t  = c * 2
+        for c in (50, 500, 5000):
+            t = c * 2
             e = int(utmups.easting  % t)
             n = int(utmups.northing % t)
             if (e == c and n in (c, c - 1)) or \
@@ -439,7 +358,7 @@ def _lowerleft(utmups, center):  # by .ellipsoidalBase._lowerleft
 
     r = _xkwds_not(None, datum=utmups.datum,
                          gamma=utmups.gamma,
-                         scale=utmups.scale)
+                         scale=utmups.scale, name=utmups.name)
     return utmups.classof(utmups.zone, utmups.hemisphere,
                           utmups.easting - e, utmups.northing - n,
                           band=utmups.band, falsed=utmups.falsed, **r)
@@ -489,12 +408,89 @@ def _parseUTMUPS5(strUTMUPS, UPS, Error=ParseError, band=NN, sep=_COMMA_):
                              strUTMUPS=strUTMUPS, Error=Error)
 
 
+def _to4lldn(latlon, lon, datum, name, wrap=False):
+    '''(INTERNAL) Return 4-tuple (C{lat, lon, datum, name}).
+    '''
+    try:
+        # if lon is not None:
+        #     raise AttributeError
+        lat, lon = float(latlon.lat), float(latlon.lon)
+        _xinstanceof(_LLEB, LatLonDatum5Tuple, latlon=latlon)
+        if wrap:
+            _Wrap.latlon(lat, lon)
+        d = datum or latlon.datum
+    except AttributeError:  # TypeError
+        lat, lon = _Wrap.latlonDMS2(latlon, lon) if wrap else \
+                          parseDMS2(latlon, lon)  # clipped
+        d = datum or _WGS84
+    return lat, lon, d, _name__(name, _or_nameof=latlon)
+
+
 def _toMgrs(utmups):
     '''(INTERNAL) Convert a L{Utm} or L{Ups} to an L{Mgrs} instance.
     '''
     return _MODS.mgrs.toMgrs(utmups, datum=utmups.datum, name=utmups.name)
 
 
+def _to3zBhp(zone, band, hemipole=NN, Error=_ValueError):  # in .epsg, .ups, .utm, .utmups
+    '''Parse UTM/UPS zone, Band letter and hemisphere/pole letter.
+
+       @arg zone: Zone with/-out Band (C{scalar} or C{str}).
+       @kwarg band: Optional I{longitudinal/polar} Band letter (C{str}).
+       @kwarg hemipole: Optional hemisphere/pole letter (C{str}).
+       @kwarg Error: Optional error to raise, overriding the default
+                     C{ValueError}.
+
+       @return: 3-Tuple (C{zone, Band, hemisphere/pole}) as (C{int, str,
+                'N'|'S'}) where C{zone} is C{0} for UPS or C{1..60} for
+                UTM and C{Band} is C{'A'..'Z'} I{NOT} checked for valid
+                UTM/UPS bands.
+
+       @raise ValueError: Invalid B{C{zone}}, B{C{band}} or B{C{hemipole}}.
+    '''
+    try:
+        B, z = band, _UTMUPS_ZONE_INVALID
+        if isscalar(zone):
+            z = int(zone)
+        elif zone and isstr(zone):
+            if zone.isdigit():
+                z = int(zone)
+            elif len(zone) > 1:
+                B = zone[-1:]
+                z = int(zone[:-1])
+            elif zone.upper() in _UPS_BANDS:  # single letter
+                B =  zone
+                z = _UPS_ZONE
+
+        if _UTMUPS_ZONE_MIN <= z <= _UTMUPS_ZONE_MAX:
+            hp = hemipole[:1].upper()
+            if hp in _NS_ or not hp:
+                z = Zone(z)
+                B = Band(B.upper())
+                if B.isalpha():
+                    return z, B, (hp or _hemi(B, _N_))
+                elif not B:
+                    return z, B, hp
+
+        raise ValueError()  # _invalid_
+    except (AttributeError, IndexError, TypeError, ValueError) as x:
+        raise Error(zone=zone, band=B, hemipole=hemipole, cause=x)
+
+
+def _to3zll(lat, lon):  # in .ups, .utm
+    '''Wrap lat- and longitude and determine UTM zone.
+
+       @arg lat: Latitude (C{degrees}).
+       @arg lon: Longitude (C{degrees}).
+
+       @return: 3-Tuple (C{zone, lat, lon}) as (C{int}, C{degrees90},
+                C{degrees180}) where C{zone} is C{1..60} for UTM.
+    '''
+    x = wrap360(lon + _180_0)  # use wrap360 to get ...
+    z = int(x) // 6 + 1  # ... longitudinal UTM zone [1, 60] and ...
+    return Zone(z), lat, (x - _180_0)  # ... -180 <= lon < 180
+
+
 __all__ += _ALL_DOCS(UtmUpsBase)
 
 # **) MIT License

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.06'
+
+_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,
@@ -643,7 +645,7 @@ def iscolinearWith(point, point1, point2, eps=EPS, useZ=True):
        @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):
@@ -869,9 +871,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 +921,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.07'
 
 
 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}}.
@@ -759,6 +757,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.