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

pygeodesy/props.py

@@ -12,22 +12,24 @@ choices, see callable L{DeprecationWarnings} below.
 
 from pygeodesy.basics import isclass as _isclass
 from pygeodesy.errors import _AssertionError, _AttributeError, \
-                             _xcallable, _xkwds, _xkwds_get
+                             _xcallable, _xkwds_get
+# from pygeodesy.internals import _tailof  # from .lazily
 from pygeodesy.interns import MISSING, NN, _an_, _COMMASPACE_, \
                              _DEPRECATED_, _DOT_, _EQUALSPACED_, \
-                             _immutable_, _invalid_, _module_, _N_A_, \
-                             _not_, _SPACE_, _UNDER_,  _DNL_  # PYCHOK used!
+                             _immutable_, _invalid_, _module_, \
+                             _N_A_, _NL_, _not_, _SPACE_, _UNDER_
 # from pygeodesy.named import callname  # _MODS, avoid circular
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
-                             _FOR_DOCS, _WARNINGS_X_DEV
+                             _FOR_DOCS, _WARNINGS_X_DEV,  _tailof
 # from pygeodesy.streprs import Fmt  # _MODS
 
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '24.09.02'
+__version__ = '24.11.06'
 
 _class_       = 'class'
+_DNL_         = _NL_ * 2  # PYCHOK used!
 _dont_use_    = _DEPRECATED_ + ", don't use."
 _function_    = 'function'
 _has_been_    = 'has been'  # PYCHOK used!
@@ -367,7 +369,7 @@ class _property_RO___(_PropertyBase):
         '''
         _PropertyBase.__init__(self, method, self._fget, self._fset_error, doc=doc)
 
-    def _fdel(self, unused):  # PYCHOK no cover
+    def _fdel(self, *unused):  # PYCHOK no cover
         '''Silently ignored, always.
         '''
         pass
@@ -650,23 +652,42 @@ class DeprecationWarnings(object):
         '''
         return self.Warnings
 
+    @property_ROver
+    def _Fmt(self):
+        '''Get C{streprs.Fmt}, I{once}.
+        '''
+        return _MODS.streprs.Fmt
+
+    @property_ROver
+    def _stacklevel3(self):
+        '''Get C{dict(stacklevel=3)}, I{once}.
+        '''
+        return dict(stacklevel=3)
+
     def throw(self, kind, name, doc, **stacklevel):  # stacklevel=3
         '''Report or raise a C{DeprecationWarning}.
+
+           @arg kind: Warning kind (C{str}), C{"method"}, C{"funtion"}, ...
+           @arg name: Qualified name (C{str}) of B{C{kind}}.
+           @arg doc: The __doc__ (C{str}) of B{C{kind}}, C{"DEPRECATED ...}.
         '''
-        line =  doc.split(_DNL_, 1)[0].strip()
-        name = _MODS.streprs.Fmt.CURLY(L=name)
-        text = _SPACE_(kind, name, _has_been_, *line.split())
-        kwds = _xkwds(stacklevel, stacklevel=3)
+        link = _tailof(name) or name
+        if link is not name:  # make "link<name>"
+            link = self._Fmt.ANGLE(link, name)
+        link =  self._Fmt.CURLY(L=link)  # "L{link}"
+        text =  doc.split(_DNL_, 1)[0].strip()
+        text = _SPACE_(kind, link, _has_been_, *text.split())
+        kwds =  stacklevel if stacklevel else self._stacklevel3
         # XXX invoke warn or raise DeprecationWarning(text)
         self._warn(text, category=DeprecationWarning, **kwds)
         self._Warnings += 1
 
-    @Property_RO
+    @property_ROver
     def _warn(self):
-        '''Get Python's C{warnings.warn}.
+        '''Get Python's C{warnings.warn} function, I{once}.
         '''
-        from warnings import warn
-        return warn
+        from warnings import warn as w
+        return w
 
     @property_RO
     def Warnings(self):

pygeodesy/resections.py

@@ -34,7 +34,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d
 from math import cos, atan2, degrees, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.resections
-__version__ = '24.09.23'
+__version__ = '24.11.04'
 
 _concyclic_ = 'concyclic'
 _PA_        = 'PA'
@@ -200,11 +200,11 @@ def cassini(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
                              alpha=alpha, beta=beta, cause=x)
 
 
-def _Clas(where, point, Clas_and_kwds, *args):
+def _Clas(which, point, Clas_and_kwds, *args):
     '''(INTERNAL) Return a C{B{Clas}=point.classof} survey point.
     '''
     Clas, kwds = _xkwds_pop2(Clas_and_kwds, Clas=point.classof)
-    return Clas(*args, **_xkwds(kwds, name=where.__name__))
+    return Clas(*args, **_xkwds(kwds, name=which.__name__))
 
 
 def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
@@ -252,8 +252,8 @@ def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
 
     def _xyz(d, r, A, B, C, useZ):
         s, c = sincos2(r)
-        x =  A.x + d * s
-        y =  A.y + d * c
+        x =  d * s + A.x  # fma(d, s, A.x)
+        y =  d * c + A.y  # fma(d, c, A.y)
         z = _zidw(x, y, useZ, A, B, C)
         return x, y, z
 
@@ -282,11 +282,10 @@ def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
         d =  b * sin(zb - zh) / sra  # A.minus(P).length
         r =  zh - ra  # zb - PI + (PI - ra - (zb - zh))
         P = _xyz(d, r, A, B, C, useZ)
-        P = _Clas(collins5, pointA, Clas_and_kwds, *P)
 
+        P = _Clas(collins5, pointA, Clas_and_kwds, *P)
         H = _Clas(collins5, pointA, Clas_and_kwds, *H)
         a =  B.minus(C).length
-
         return Collins5Tuple(P, H, a, b, c, name=collins5.__name__)
 
     except (TypeError, ValueError) as x:
@@ -312,7 +311,7 @@ def pierlot(point1, point2, point3, alpha12, alpha23, useZ=False, eps=EPS,
                      B{C{alpha3 - alpha2}}(C{degrees}).
        @kwarg useZ: If C{True}, interpolate the survey point's Z component,
                     otherwise use C{z=INT0} (C{bool}).
-       @kwarg eps: Tolerance for C{cot} (pseudo-)singularities (C{float}).
+       @kwarg eps: Tolerance for C{cot}angent (pseudo-)singularities (C{float}).
        @kwarg Clas_and_kwds: Optional class C{B{Clas}=B{point1}.classof} to
                    return the survey point with optionally other B{C{Clas}}
                    keyword arguments to instantiate the survey point.
@@ -427,8 +426,8 @@ def pierlotx(point1, point2, point3, alpha1, alpha2, alpha3, useZ=False,
                    return the survey point with optionally other B{C{Clas}}
                    keyword arguments to instantiate the survey point.
 
-       @return: The survey (or robot) point, an instance of B{C{Clas}} or B{C{point1}}'s
-                (sub-)class.
+       @return: The survey (or robot) point, an instance of B{C{Clas}} or
+                B{C{point1}}'s (sub-)class.
 
        @raise ResectionError: Near-coincident, -colinear or -concyclic points or
                               invalid B{C{alpha1}}, B{C{alpha2}} or B{C{alpha3}}.

pygeodesy/rhumb/__init__.py

@@ -9,7 +9,7 @@ u'''Package of lazily imported C{rhumb} modules L{rhumb.aux_}, L{rhumb.ekx} and
 from pygeodesy.lazily import _ALL_LAZY, _ALL_OTHER, _lazy_import_as, _unLazy0
 
 __all__ = _ALL_LAZY.rhumb
-__version__ = '24.09.02'
+__version__ = '24.11.07'
 
 if _unLazy0:  # or _isfrozen
     from pygeodesy.rhumb.aux_ import RhumbAux, RhumbLineAux

pygeodesy/rhumb/bases.py

@@ -33,7 +33,7 @@ from pygeodesy.errors import IntersectionError, RhumbError, _xdatum, \
 from pygeodesy.fmath import euclid, favg, sqrt_a,  Fsum
 # from pygeodesy.formy import opposing  # _MODS
 # from pygeodesy.fsums import Fsum  # from .fmath
-from pygeodesy.internals import _dunder_nameof, _under
+from pygeodesy.internals import _DUNDER_nameof, _under
 from pygeodesy.interns import NN, _coincident_, _COMMASPACE_, _Dash, \
                              _parallel_, _too_
 from pygeodesy.karney import _atan2d, Caps, _CapsBase, _diff182, _fix90, \
@@ -52,7 +52,7 @@ from pygeodesy.vector3d import _intersect3d3, Vector3d  # in .Intersection below
 from math import cos, fabs
 
 __all__ = ()
-__version__ = '24.06.18'
+__version__ = '24.10.14'
 
 _anti_ = _Dash('anti')
 _rls   = []  # instances of C{RbumbLine...} to be updated
@@ -634,7 +634,7 @@ class RhumbLineBase(_CapsBase):
         t = dict(lat3=q.lat2, lon3=q.lon2, azi03=q.azi02, a03=q.a02, s03=a)
         if a < r:
             t.update(iteration=q.iteration, lat0=q.lat1, lon0=q.lon1,  # or lat0, lon0
-                     name=_dunder_nameof(self.Intersecant2, self.name))
+                     name=_DUNDER_nameof(self.Intersecant2, self.name))
             if fabs(a) < EPS0:  # coincident centers
                 d, h = _0_0, r
             else:
@@ -723,7 +723,7 @@ class RhumbLineBase(_CapsBase):
 
             P = GDict(lat1=self.lat1, lat2=p.lat, lat0=other.lat1,
                       lon1=self.lon1, lon2=p.lon, lon0=other.lon1,
-                      name=_dunder_nameof(self.Intersection, self.name))
+                      name=_DUNDER_nameof(self.Intersection, self.name))
             r =  self.Inverse(p.lat, p.lon, outmask=Caps.DISTANCE)
             t = other.Inverse(p.lat, p.lon, outmask=Caps.DISTANCE)
             P.set_(azi12= self.azi12, a12=r.a12, s12=r.s12,
@@ -897,7 +897,7 @@ class RhumbLineBase(_CapsBase):
                         break
                 P.set_(azi0=r.azi1, a02=r.a12, s02=r.s12,  # azi2=r.azi2,
                        lat0=lat0, lon0=lon0, iteration=i, at=r.azi2 - self.azi12,
-                       name=_dunder_nameof(self.PlumbTo, self.name))
+                       name=_DUNDER_nameof(self.PlumbTo, self.name))
             except Exception as x:  # Fsum(NAN) Value-, ZeroDivisionError
                 raise IntersectionError(lat0=lat0, lon0=lon0, tol=tol, exact=exact,
                                         eps=eps, est=est, iteration=i, cause=x)

pygeodesy/rhumb/solve.py

@@ -12,16 +12,15 @@ from pygeodesy.basics import _xinstanceof
 from pygeodesy.constants import _0_0, _180_0, _N_180_0, _over,  _90_0  # PYCHOK used!
 from pygeodesy.errors import RhumbError   # PYCHOK used!
 from pygeodesy.interns import NN, _a12_, _azi12_, _lat2_, _lon2_, _s12_, _S12_, _UNDER_
-from pygeodesy.karney import Caps, GDict, _norm180, Rhumb8Tuple, _sincos2d
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv, \
-                             _PYGEODESY_RHUMBSOLVE_
+from pygeodesy.karney import Caps, GDict, _norm180, Rhumb8Tuple, _sincos2d, _Xables
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
 from pygeodesy.props import deprecated_method, Property, Property_RO
 from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.rhumb_solve
-__version__ = '24.08.13'
+__version__ = '24.11.07'
 
 
 class _RhumbSolveBase(_SolveGDictBase):
@@ -30,8 +29,8 @@ class _RhumbSolveBase(_SolveGDictBase):
     _Error         =  RhumbError
     _Names_Direct  = _lat2_, _lon2_, _S12_
     _Names_Inverse = _azi12_, _s12_, _S12_
-    _Xable_name    = 'RhumbSolve'
-    _Xable_path    = _getenv(_PYGEODESY_RHUMBSOLVE_, _PYGEODESY_RHUMBSOLVE_)
+    _Xable_name    = _Xables.RhumbSolve.__name__
+    _Xable_path    = _Xables.RhumbSolve()
 
     @Property_RO
     def _cmdBasic(self):
@@ -184,7 +183,7 @@ class RhumbSolve(_RhumbSolveBase):
     def _Inverse(self, ll1, ll2, wrap, **unused):
         '''(INTERNAL) Short-cut version, see .latlonBase.
         '''
-        if wrap:
+        if wrap:  # PYCHOK no cover
             ll2 = _unrollon(ll1, _Wrap.point(ll2))
         return self._GDictInverse(ll1.lat, ll1.lon, ll2.lat, ll2.lon)
 
@@ -202,7 +201,7 @@ class RhumbSolve(_RhumbSolveBase):
     def _InverseLine(self, ll1, ll2, wrap, **name_caps):
         '''(INTERNAL) Short-cut version, see .latlonBase.
         '''
-        if wrap:
+        if wrap:  # PYCHOK no cover
             ll2 = _unrollon(ll1, _Wrap.point(ll2))
         return self.InverseLine(ll1.lat, ll1.lon, ll2.lat, ll2.lon, **name_caps)
 
@@ -394,8 +393,8 @@ if __name__ == '__main__':
     rS = RhumbSolve(name='Test')
     rS.verbose = '--verbose' in argv  # or '-v' in argv
 
-    if rS.RhumbSolve in (_PYGEODESY_RHUMBSOLVE_, None):  # not set
-        rS.RhumbSolve = '/opt/local/bin/RhumbSolve'  # '/opt/local/Cellar/geographiclib/2.3/bin/RhumbSolve'  # HomeBrew
+    if not _Xables.X_OK(rS.RhumbSolve):  # not set
+        rS.RhumbSolve = _Xables.RhumbSolve(_Xables.bin_)
     printf('version: %s', rS.version)
 
     if len(argv) > 6:  # 60 0 30 0 45 1e6

pygeodesy/simplify.py

@@ -76,7 +76,7 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 # from pygeodesy.basics import len2  # from .fmath
 from pygeodesy.constants import EPS, R_M, _1_0
 from pygeodesy.errors import _AttributeError, _ValueError
-from pygeodesy.fmath import len2, sqrt0
+from pygeodesy.fmath import fdot_, len2, sqrt0
 from pygeodesy.formy import equirectangular4
 from pygeodesy.interns import _small_, _too_
 from pygeodesy.iters import isNumpy2, isTuple2
@@ -86,7 +86,7 @@ from pygeodesy.units import _ALL_LAZY, _1mm, Radius_
 from math import degrees, fabs, radians
 
 __all__ = _ALL_LAZY.simplify
-__version__ = '24.08.13'
+__version__ = '24.11.07'
 
 
 # try:
@@ -222,11 +222,11 @@ class _Sy(object):
             # distance points[i] to -[s]
             d2, y01, x01, _ = _d2yxu4(s, i)
             if d2 > eps:
-                w = y01 * y21 + x01 * x21
+                w = fdot_(y01, y21, x01, x21)
                 if w > 0:
                     if w < d21:
                         # perpendicular distance squared
-                        d2 = (y01 * x21 - x01 * y21)**2 / d21
+                        d2 = fdot_(y01, x21, -x01, y21)**2 / d21
                     else:  # distance points[i] to -[e]
                         d2, _, _, _ = _d2yxu4(e, i)
                 if d2 > t2:
@@ -252,7 +252,7 @@ class _Sy(object):
         if d21 > self.eps:
             d01, y01, x01, _ = self.d2yxu4(i1, i0)
             if d01 > self.eps:
-                h2 = fabs(y01 * x21 - x01 * y21)
+                h2 = fabs(fdot_(y01, x21, -x01, y21))
                 # triangle height h = h2 / sqrt(d21) and
                 # the area = h * sqrt(d21) / 2 == h2 / 2
                 return h2  # double triangle area

pygeodesy/solveBase.py

@@ -4,36 +4,28 @@
 u'''(INTERNAL) Private base classes for L{pygeodesy.geodsolve} and L{pygeodesy.rhumb.solve}.
 '''
 
-from pygeodesy.basics import clips, map2, ub2str, _zip
+from pygeodesy.basics import clips, map2, _zip
 from pygeodesy.constants import DIG
 from pygeodesy.datums import _earth_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.errors import _AssertionError, _xkwds_get, _xkwds_get1, \
                              _xkwds_item2
-from pygeodesy.internals import _enquote, printf
+from pygeodesy.internals import _enquote, _popen2, printf
 from pygeodesy.interns import NN, _0_, _AT_,_BACKSLASH_, _COLONSPACE_, \
                              _COMMASPACE_, _EQUAL_, _Error_, _SPACE_, \
                              _UNUSED_
 from pygeodesy.karney import Caps, _CapsBase, GDict
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _sys_version_info2
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 from pygeodesy.named import callername, _name2__, notOverloaded
 from pygeodesy.props import Property, Property_RO, property_RO, _update_all
 from pygeodesy.streprs import Fmt, fstr, fstrzs, pairs, strs
 from pygeodesy.units import Precision_
 from pygeodesy.utily import unroll180,  wrap360  # PYCHOK shared
 
-from subprocess import PIPE as _PIPE, Popen as _Popen, STDOUT as _STDOUT
-
 __all__ = _ALL_LAZY.solveBase
-__version__ = '24.07.11'
+__version__ = '24.10.13'
 
-_ERROR_     = 'ERROR'
-_Popen_kwds =  dict(creationflags=0,
-                  # executable=sys.executable, shell=True,
-                    stdin=_PIPE, stdout=_PIPE, stderr=_STDOUT)
-if _sys_version_info2 > (3, 6):
-    _Popen_kwds.update(text=True)
-del _PIPE, _STDOUT, _sys_version_info2  # _ALL_LAZY
+_ERROR_ = 'ERROR'
 
 
 def _cmd_stdin_(cmd, stdin):  # PYCHOK no cover
@@ -53,15 +45,6 @@ def _cmd_stdin_(cmd, stdin):  # PYCHOK no cover
 #     return i if float(i) == f else f  # PYCHOK inconsistent
 
 
-def _popen2(cmd, stdin=None):  # in .mgrs, test.bases, .testMgrs
-    '''(INTERNAL) Invoke C{B{cmd} tuple} and return C{exitcode}
-       and all output from C{stdout/-err}, I{stripped}.
-    '''
-    p = _Popen(cmd, **_Popen_kwds)  # PYCHOK kwArgs
-    r =  p.communicate(stdin)[0]  # stdout + NL + stderr
-    return p.returncode, ub2str(r).strip()
-
-
 class _SolveCapsBase(_CapsBase):
     '''(NTERNAL) Base class for C{_SolveBase} and C{_LineSolveBase}.
     '''
@@ -85,8 +68,7 @@ class _SolveCapsBase(_CapsBase):
         return self.ellipsoid.a
 
     @property_RO
-    def _cmdBasic(self):  # PYCHOK no cover
-        '''(INTERNAL) I{Must be overloaded}.'''
+    def _cmdBasic(self):  # PYCHOK no covers        '''(INTERNAL) I{Must be overloaded}.'''
         notOverloaded(self, underOK=True)
 
     @property_RO
@@ -228,7 +210,7 @@ class _SolveCapsBase(_CapsBase):
             t = _cmd_stdin_(cmd, stdin)
             self._print(t)
         try:  # invoke and write to stdin
-            s, r = _popen2(cmd, stdin)
+            r, s = _popen2(cmd, stdin)
             if len(r) < 6 or r[:5] in (_Error_, _ERROR_):
                 raise ValueError(r)
         except (IOError, OSError, TypeError, ValueError) as x:

pygeodesy/sphericalBase.py

@@ -5,7 +5,7 @@ u'''(INTERNAL) Private spherical base classes C{CartesianSphericalBase} and
 C{LatLonSphericalBase} for L{sphericalNvector} and L{sphericalTrigonometry}.
 
 A pure Python implementation of geodetic (lat-/longitude) functions,
-transcoded in part from JavaScript originals by I{(C) Chris Veness 2011-2016}
+transcoded in part from JavaScript originals by I{(C) Chris Veness 2011-2024}
 and published under the same MIT Licence**, see
 U{Latitude/Longitude<https://www.Movable-Type.co.UK/scripts/latlong.html>}.
 '''
@@ -40,7 +40,7 @@ from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
 from math import cos, fabs, log, sin, sqrt
 
 __all__ = _ALL_LAZY.sphericalBase
-__version__ = '24.08,13'
+__version__ = '24.10.19'
 
 
 class CartesianSphericalBase(CartesianBase):
@@ -126,24 +126,23 @@ class LatLonSphericalBase(LatLonBase):
            @kwarg lon: Longitude (C{degrees} or DMS C{str} with E or W suffix) or
                        C(None), indicating B{C{latlonh}} is a C{LatLon}.
            @kwarg height: Optional height above (or below) the earth surface (C{meter},
-                          same units as the datum's ellipsoid axes or radius).
+                          same units as the datum's radius or axes).
            @kwarg datum: Optional, spherical datum to use (L{Datum}, L{Ellipsoid},
-                         L{Ellipsoid2}, L{a_f2Tuple}) or earth radius in C{meter},
-                         conventionally).
+                         L{Ellipsoid2}, L{a_f2Tuple}) or the mean earth radius
+                         (C{meter}, conventionally).
            @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
                         (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @raise TypeError: If B{C{latlonh}} is not a C{LatLon} or B{C{datum}} not
-                             spherical.
+           @raise TypeError: Invalid B{C{latlonh}} or B{C{datum}} not spherical.
         '''
         LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, **name)
         if datum not in (None, self.datum):
             self.datum = datum
 
     def bearingTo2(self, other, wrap=False, raiser=False):
-        '''Return the initial and final bearing (forward and reverse
-           azimuth) from this to an other point.
+        '''Return the initial and final bearing (forward and reverse azimuth)
+           from this to an other point.
 
            @arg other: The other point (C{LatLon}).
            @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
@@ -204,10 +203,10 @@ class LatLonSphericalBase(LatLonBase):
 
            @arg circle: Radius of the circle centered at this location (C{meter},
                         same units as B{C{radius}}) or a point on the circle
-                        (this C{LatLon}).
-           @arg point: A point on the (great circle) line (this C{LatLon}).
-           @arg other: An other point I{on} (this {LatLon}) or the bearing at
-                       B{C{point}} I{of} the (great circle) line (compass
+                        (same C{LatLon} class).
+           @arg point: A point on the (great circle) line (same C{LatLon} class).
+           @arg other: An other point I{on} (same C{LatLon} class) or the bearing
+                       at B{C{point}} I{of} the (great circle) line (compass
                        C{degrees}).
            @kwarg radius: Mean earth radius (C{meter}, conventionally).
            @kwarg exact: If C{True}, use the I{exact} rhumb methods for azimuth,
@@ -216,8 +215,8 @@ class LatLonSphericalBase(LatLonBase):
                          circle} methods.
            @kwarg height: Optional height for the intersection points (C{meter},
                           conventionally) or C{None} for interpolated heights.
-           @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the points
-                        B{C{circle}}, B{C{point}} and/or B{C{other}} (C{bool}).
+           @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{circle}},
+                         B{C{point}} and B{C{other}} iff points (C{bool}).
 
            @return: 2-Tuple of the intersection points (representing a chord), each
                     an instance of the B{C{point}} class.  Both points are the same
@@ -225,8 +224,7 @@ class LatLonSphericalBase(LatLonBase):
 
            @raise IntersectionError: The circle and line do not intersect.
 
-           @raise TypeError: If B{C{point}} is not this C{LatLon} or B{C{circle}}
-                             or B{C{other}} invalid.
+           @raise TypeError: Invalid B{C{point}}, B{C{circle}} or B{C{other}}.
 
            @raise UnitError: Invalid B{C{circle}}, B{C{other}}, B{C{radius}},
                              B{C{exact}}, B{C{height}} or B{C{napieradius}}.
@@ -469,8 +467,8 @@ class LatLonSphericalBase(LatLonBase):
 
            @arg circle: Radius of the circle centered at this location (C{meter},
                         same units as B{C{radius}}) or a point on the circle
-                        (this C{LatLon}).
-           @arg point: The rhumb line's start point (this C{LatLon}).
+                        (same C{LatLon} class).
+           @arg point: The rhumb line's start point (same C{LatLon} class).
            @arg other: An other point (this I{on} C{LatLon}) or the azimuth I{of}
                        (compass C{degrees}) the rhumb line.
            @kwarg radius: Mean earth radius (C{meter}, conventionally).
@@ -489,8 +487,7 @@ class LatLonSphericalBase(LatLonBase):
 
            @raise IntersectionError: The circle and line do not intersect.
 
-           @raise TypeError: If B{C{point}} is not this C{LatLon} or B{C{circle}}
-                             or B{C{other}} invalid.
+           @raise TypeError: Invalid B{C{point}}, B{C{circle}} or B{C{other}}.
 
            @raise UnitError: Invalid B{C{circle}}, B{C{other}}, B{C{radius}},
                              B{C{exact}} or B{C{height}}.
@@ -502,8 +499,8 @@ class LatLonSphericalBase(LatLonBase):
 
     def rhumbMidpointTo(self, other, height=None, radius=R_M, exact=False,
                                                 fraction=_0_5, **wrap_name):
-        '''Return the (loxodromic) midpoint on the rhumb line between
-           this and an other point.
+        '''Return the (loxodromic) midpoint on the rhumb line between this
+           and an other point.
 
            @arg other: The other point (spherical LatLon).
            @kwarg height: Optional height, overriding the mean height (C{meter}).