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

pygeodesy/units.py

@@ -1,18 +1,17 @@
 
 # -*- coding: utf-8 -*-
 
-u'''Various units, all sub-classes of C{Float}, C{Int} and
-C{Str} from basic C{float}, C{int} respectively C{str} to
-named units as L{Degrees}, L{Feet}, L{Meter}, L{Radians}, etc.
+u'''Various named units, all sub-classes of C{Float}, C{Int} or C{Str} from
+basic C{float}, C{int} respectively C{str} to named units as L{Degrees},
+L{Feet}, L{Meter}, L{Radians}, etc.
 '''
 
-from pygeodesy.basics import isinstanceof, isscalar, isstr, issubclassof, signOf
+from pygeodesy.basics import isscalar, isstr, issubclassof, signOf, _xsubclassof
 from pygeodesy.constants import EPS, EPS1, PI, PI2, PI_2, _umod_360, _0_0, \
                                _0_001,  _0_5, INT0  # PYCHOK for .mgrs, .namedTuples
-from pygeodesy.dms import F__F, F__F_, S_NUL, S_SEP, parseDMS, parseRad, \
-                         _toDMS, toDMS
+from pygeodesy.dms import F__F, F__F_, S_NUL, S_SEP, parseDMS, parseRad, _toDMS
 from pygeodesy.errors import _AssertionError, _IsnotError, TRFError, UnitError, \
-                             _xkwds
+                             _xattr
 from pygeodesy.interns import NN, _band_, _bearing_, _degrees_, _degrees2_, \
                              _distance_, _E_, _easting_, _epoch_, _EW_, _feet_, \
                              _height_, _lam_, _lat_, _LatLon_, _lon_, _meter_, \
@@ -29,7 +28,7 @@ from pygeodesy.unitsBase import _Error, Float, Fmt, fstr, Int, _arg_name_arg2, \
 from math import degrees, radians
 
 __all__ = _ALL_LAZY.units
-__version__ = '24.05.20'
+__version__ = '24.06.10'
 
 _negative_falsed_ = 'negative, falsed'
 
@@ -108,10 +107,9 @@ class Bool(Int, _NamedUnit):
            @kwarg cls: This class (C{Bool} or sub-class).
            @kwarg arg: The value (any C{type} convertable to C{bool}).
            @kwarg name: Optional instance name (C{str}).
-           @kwarg Error: Optional error to raise, overriding the default
-                         L{UnitError}.
-           @kwarg name_arg: Optional C{name=arg} keyword argument, inlieu
-                            of B{C{name}} and B{C{arg}}.
+           @kwarg Error: Optional error to raise, overriding the default L{UnitError}.
+           @kwarg name_arg: Optional C{name=arg} keyword argument, inlieu of separate
+                            B{C{name}} and B{C{arg}}.
 
            @returns: A L{Bool}, a C{bool}-like instance.
 
@@ -137,13 +135,11 @@ class Bool(Int, _NamedUnit):
     def toRepr(self, std=False, **unused):  # PYCHOK **unused
         '''Return a representation of this C{Bool}.
 
-           @kwarg std: Use the standard C{repr} or the named
-                       representation (C{bool}).
+           @kwarg std: Use the standard C{repr} or the named representation (C{bool}).
 
-           @note: Use C{env} variable C{PYGEODESY_BOOL_STD_REPR=std}
-                  prior to C{import pygeodesy} to get the standard
-                  C{repr} or set property C{std_repr=False} to always
-                  get the named C{toRepr} representation.
+           @note: Use C{env} variable C{PYGEODESY_BOOL_STD_REPR=std} prior to C{import
+                  pygeodesy} to get the standard C{repr} or set property C{std_repr=False}
+                  to always get the named C{toRepr} representation.
         '''
         r = repr(self._bool_True_or_False)
         return r if std else self._toRepr(r)
@@ -174,17 +170,16 @@ class Degrees(Float):
         '''New C{Degrees} instance, see L{Float}.
 
            @arg cls: This class (C{Degrees} or sub-class).
-           @kwarg arg: The value (any scalar C{type} convertable to C{float} or
-                       parsable by L{pygeodesy.parseDMS}).
+           @kwarg arg: The value (any scalar C{type} convertable to C{float} or parsable
+                       by L{pygeodesy.parseDMS}).
            @kwarg name: Optional instance name (C{str}).
-           @kwarg Error: Optional error to raise, overriding the default
-                         L{UnitError}.
+           @kwarg Error: Optional error to raise, overriding the default L{UnitError}.
            @kwarg suffix: Optional, valid compass direction suffixes (C{NSEW}).
-           @kwarg clip: Optional B{C{arg}} range B{C{-clip..+clip}}
-                        (C{degrees} or C{0} or C{None} for unclipped).
+           @kwarg clip: Optional B{C{arg}} range B{C{-clip..+clip}} (C{degrees} or C{0}
+                        or C{None} for unclipped).
            @kwarg wrap: Optionally adjust the B{C{arg}} value (L{pygeodesy.wrap90},
                         L{pygeodesy.wrap180} or L{pygeodesy.wrap360}).
-           @kwarg name_arg: Optional C{name=arg} keyword argument, inlieu of
+           @kwarg name_arg: Optional C{name=arg} keyword argument, inlieu of separate
                             B{C{name}} and B{C{arg}}.
 
            @returns: A C{Degrees} instance.
@@ -218,18 +213,18 @@ class Degrees(Float):
     def toRepr(self, std=False, **prec_fmt_ints):  # PYCHOK prec=8, ...
         '''Return a representation of this C{Degrees}.
 
-           @kwarg std: If C{True} return the standard C{repr},
-                       otherwise the named representation (C{bool}).
+           @kwarg std: If C{True} return the standard C{repr}, otherwise
+                       the named representation (C{bool}).
 
            @see: Methods L{Degrees.toStr}, L{Float.toRepr} and function
-                 L{pygeodesy.toDMS} for more documentation.
+                 L{pygeodesy.toDMS} for futher C{prec_fmt_ints} details.
         '''
         return Float.toRepr(self, std=std, **prec_fmt_ints)
 
     def toStr(self, prec=None, fmt=F__F_, ints=False, **s_D_M_S):  # PYCHOK prec=8, ...
         '''Return this C{Degrees} as standard C{str}.
 
-           @see: Function L{pygeodesy.toDMS} for keyword argument details.
+           @see: Function L{pygeodesy.toDMS} for futher details.
         '''
         if fmt.startswith(_PERCENT_):  # use regular formatting
             p = 8 if prec is None else prec
@@ -288,8 +283,8 @@ class Radians(Float):
         '''New C{Radians} instance, see L{Float}.
 
            @arg cls: This class (C{Radians} or sub-class).
-           @kwarg arg: The value (any C{type} convertable to C{float} or parsable
-                       by L{pygeodesy.parseRad}).
+           @kwarg arg: The value (any C{type} convertable to C{float} or parsable by
+                       L{pygeodesy.parseRad}).
            @kwarg name: Optional instance name (C{str}).
            @kwarg Error: Optional error to raise, overriding the default L{UnitError}.
            @kwarg suffix: Optional, valid compass direction suffixes (C{NSEW}).
@@ -547,7 +542,7 @@ class FIx(Float_):
            @arg points: The points (C{LatLon}[], L{Numpy2LatLon}[],
                         L{Tuple2LatLon}[] or C{other}[]).
            @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                        B{C{points}} (C{bool})  C{None} for backward
+                        B{C{points}} (C{bool}) or C{None} for backward
                         compatible L{LatLon2Tuple} or B{C{LatLon}} with
                         I{averaged} lat- and longitudes.
            @kwarg LatLon: Optional class to return the I{intermediate},
@@ -695,10 +690,9 @@ class Meter(Float):
 
            @see: Method C{Str.toRepr} and property C{Str.std_repr}.
 
-           @note: Use C{env} variable C{PYGEODESY_METER_STD_REPR=std}
-                  prior to C{import pygeodesy} to get the standard
-                  C{repr} or set property C{std_repr=False} to always
-                  get the named C{toRepr} representation.
+           @note: Use C{env} variable C{PYGEODESY_METER_STD_REPR=std} prior to C{import
+                  pygeodesy} to get the standard C{repr} or set property C{std_repr=False}
+                  to always get the named C{toRepr} representation.
         '''
         return self.toRepr(std=self._std_repr)
 
@@ -875,29 +869,13 @@ def _isScalar(obj):
     return isscalar(obj) and not isinstance(obj, _NamedUnit)
 
 
-def _toDegrees(s, *xs, **toDMS_kwds):
-    '''(INTERNAL) Convert C{xs} from C{Radians} to C{Degrees} or C{toDMS}.
-    '''
-    if toDMS_kwds:
-        toDMS_kwds = _xkwds(toDMS_kwds, ddd=1, pos=NN)
-
-    for x in xs:
-        if not isinstanceof(x, Degrees, Degrees_):
-            s = None
-            x = x.toDegrees()
-        yield toDMS(x, **toDMS_kwds) if toDMS_kwds else x
-    yield None if toDMS_kwds else s
-
-
-def _toRadians(s, *xs):
-    '''(INTERNAL) Convert C{xs} from C{Degrees} to C{Radians}.
+def _toUnit(Unit, arg, name=NN, **Error):
+    '''(INTERNAL) Wrap C{arg} in a C{name}d C{Unit}.
     '''
-    for x in xs:
-        if not isinstanceof(x, Radians, Radians_):
-            s = None
-            x = x.toRadians()
-        yield x
-    yield s
+    if not (issubclassof(Unit, _NamedUnit) and isinstance(arg, Unit) and
+           _xattr(arg, name=NN) == name):
+        arg = Unit(arg, name=name, **Error)
+    return arg
 
 
 def _xStrError(*Refs, **name_value_Error):
@@ -910,8 +888,7 @@ def _xStrError(*Refs, **name_value_Error):
 def _xUnit(units, Base):  # in .frechet,  .hausdorff
     '''(INTERNAL) Get C{Unit} from C{Unit} or C{name}, ortherwise C{Base}.
     '''
-    if not issubclassof(Base, _NamedUnit):
-        raise _IsnotError(_NamedUnit.__name__, Base=Base)
+    _xsubclassof(_NamedUnit, Base=Base)
     U = globals().get(units.capitalize(), Base) if isstr(units) else (
                       units if issubclassof(units, Base) else Base)
     return U if issubclassof(U, Base) else Base
@@ -920,14 +897,12 @@ def _xUnit(units, Base):  # in .frechet,  .hausdorff
 def _xUnits(units, Base=_NamedUnit):  # in .frechet, .hausdorff
     '''(INTERNAL) Set property C{units} as C{Unit} or C{Str}.
     '''
-    if not issubclassof(Base, _NamedUnit):
-        raise _IsnotError(_NamedUnit.__name__, Base=Base)
-    elif issubclassof(units, Base):
+    _xsubclassof(_NamedUnit, Base=Base)
+    if issubclassof(units, Base):
         return units
     elif isstr(units):
         return Str(units, name=_units_)  # XXX Str to _Pass and for backward compatibility
-    else:
-        raise _IsnotError(Base.__name__, Str.__name__, str.__name__, units=units)
+    raise _IsnotError(*(_.__name__ for _ in (Base, Str, str)), units=units)
 
 
 def _std_repr(*Classes):

pygeodesy/unitsBase.py

@@ -14,7 +14,7 @@ from pygeodesy.named import modulename, _Named, property_doc_
 from pygeodesy.streprs import Fmt, fstr
 
 __all__ = _ALL_LAZY.unitsBase
-__version__ = '24.05.20'
+__version__ = '24.06.05'
 
 
 class _NamedUnit(_Named):
@@ -107,7 +107,7 @@ class Float(float, _NamedUnit):
         # XXX the default number of decimals is 10-12 when using
         # float.__str__(self) with both python 3.8+ and 2.7-, but
         # float.__repr__(self) shows DIG decimals in python2.7!
-        # return super(Float, self).__repr__()  # see .test.testCss.py
+        # return super(Float, self).__repr__()  # see .testCss.py
         return float.__str__(self)  # always _std_str_
 
     def toRepr(self, std=False, **prec_fmt_ints):  # PYCHOK prec=8, ...

pygeodesy/utily.py

@@ -27,7 +27,7 @@ from pygeodesy.units import Degrees, Degrees_, Feet, Float, Lam, Lam_, \
 from math import acos, asin, atan2, cos, degrees, fabs, radians, sin, tan  # pow
 
 __all__ = _ALL_LAZY.utily
-__version__ = '24.05.29'
+__version__ = '24.06.03'
 
 # read constant name "_M_Unit" as "meter per Unit"
 _M_CHAIN     = _F(  20.1168)     # yard2m(1) * 22
@@ -1002,9 +1002,10 @@ class _Wrap(object):
     def normal(self, setting):
         '''Set L{normal} to C{True}, C{False} or C{None}.
         '''
-        t = {True: (_MODS.formy.normal, _MODS.formy.normal_),
-             False: (self.wraplatlon,    self.wraphilam),
-             None:  (_passargs,         _passargs)}.get(setting, ())
+        m = _MODS.formy
+        t = {True:  (m.normal,        m.normal_),
+             False: (self.wraplatlon, self.wraphilam),
+             None:  (_passargs,      _passargs)}.get(setting, ())
         if t:
             self.latlon, self.philam = t
             self._normal = setting

pygeodesy/utmupsBase.py

@@ -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.30'
+__version__ = '24.06.09'
 
 _UPS_BANDS = _A_, _B_, _Y_, _Z_  # UPS polar bands SE, SW, NE, NW
 # _UTM_BANDS = _MODS.utm._Bands
@@ -472,7 +472,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.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.