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

pygeodesy/geodesicw.py

@@ -37,7 +37,7 @@ from contextlib import contextmanager
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.geodesicw
-__version__ = '24.05.24'
+__version__ = '24.06.24'
 
 _plumb_ = 'plumb'
 _TRIPS  =  65
@@ -71,8 +71,8 @@ class _gWrapped(_kWrapped):
 
                    @arg a_ellipsoid: The equatorial radius I{a} (C{meter}, conventionally),
                                      an ellipsoid (L{Ellipsoid}) or a datum (L{Datum}).
-                   @arg f: The ellipsoid's flattening (C{scalar}), ignored if B{C{a_ellipsoid})
-                           is not C{meter}.
+                   @arg f: The ellipsoid's flattening (C{scalar}), required if B{C{a_ellipsoid})
+                           is C{meter}, ignored otherwise.
                    @kwarg name: Optional C{B{name}=NN} (C{str}).
                 '''
                 _earth_datum(self, a_ellipsoid, f=f, **name)  # raiser=NN
@@ -429,17 +429,16 @@ class _gWrapped(_kWrapped):
 _wrapped = _gWrapped()  # PYCHOK singleton, .ellipsoids, .test/base.py
 
 
-def Geodesic(a_ellipsoid, f=None, **name):
+def Geodesic(a_ellipsoid=_EWGS84, f=None, **name):
     '''Return a I{wrapped} C{geodesic.Geodesic} instance from I{Karney}'s
        Python U{geographiclib<https://PyPI.org/project/geographiclib>},
        provide the latter is installed, otherwise an C{ImportError}.
 
        @arg a_ellipsoid: An ellipsoid (L{Ellipsoid}) or datum (L{Datum})
               or the equatorial radius I{a} of the ellipsoid (C{meter}).
-       @arg f: The flattening of the ellipsoid (C{scalar}), ignored if
-               B{C{a_ellipsoid}}) is not specified as C{meter}.
-       @kwarg name: Optional ellipsoid C{B{name}=NN} (C{str}), ignored
-                    like B{C{f}}.
+       @arg f: The flattening of the ellipsoid (C{scalar}), required if
+               B{C{a_ellipsoid}}) is C{meter}, ignored otherwise.
+       @kwarg name: Optional C{B{name}=NN} (C{str}), ignored like B{C{f}}.
     '''
     return _wrapped.Geodesic(a_ellipsoid, f=f, **name)
 
@@ -453,11 +452,10 @@ def GeodesicLine(geodesic, lat1, lon1, azi1, caps=Caps._STD_LINE):
        @arg lat1: Latitude of the first points (C{degrees}).
        @arg lon1: Longitude of the first points (C{degrees}).
        @arg azi1: Azimuth at the first points (compass C{degrees360}).
-       @kwarg caps: Optional, bit-or'ed combination of L{Caps} values
-                    specifying the capabilities the C{GeodesicLine}
-                    instance should possess, i.e., which quantities can
-                    be returned by calls to C{GeodesicLine.Position}
-                    and C{GeodesicLine.ArcPosition}.
+       @kwarg caps: Optional, bit-or'ed combination of L{Caps} values specifying
+                    the capabilities the C{GeodesicLine} instance should possess,
+                    i.e., which quantities can be returned by methods
+                    C{GeodesicLine.Position} and C{GeodesicLine.ArcPosition}.
     '''
     return _wrapped.GeodesicLine(geodesic, lat1, lon1, azi1, caps=caps)
 

pygeodesy/geodesicx/__init__.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 u'''A pure Python version of I{Karney}'s C++ classes U{GeodesicExact
-<https://GeographicLib.SourceForge.io/C++/classGeographicLib_1_1GeodesicExact.html>}
+<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicExact.html>}
 and U{GeodesicLineExact
 <https://geographiclib.sourceforge.io/C++/doc/classGeographicLib_1_1GeodesicLine.html>}.
 
@@ -13,8 +13,8 @@ and the background information at U{Geodesics on an ellipsoid of revolution
 
 Also, compare C{GeodesicExact} and C{GeodesicLineExact} to I{standard} classes C{Geodesic}
 respectively C{GeodesicLine} from I{Karney}'s Python implementation U{geographiclib
-<https://GeographicLib.SourceForge.io/C++/doc/other.html#python>}, see module
-L{pygeodesy.karney}.
+<https://GeographicLib.SourceForge.io/C++/doc/other.html#python>}, see modules
+L{pygeodesy.geodesicw} and L{pygeodesy.karney}.
 '''
 
 from pygeodesy.geodesicx.gx import GeodesicExact, GeodesicLineExact  # PYCHOK exported
@@ -23,7 +23,7 @@ from pygeodesy.karney import Caps, GeodesicError
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 
 __all__ = _ALL_LAZY.geodesicx + _ALL_DOCS(Caps, GeodesicError)
-__version__ = '24.05.31'
+__version__ = '24.06.19'
 
 # **) MIT License
 #

pygeodesy/geodesicx/gx.py

@@ -44,25 +44,26 @@ from pygeodesy.constants import EPS, EPS0, EPS02, MANT_DIG, NAN, PI, _EPSqrt, \
 from pygeodesy.datums import _earth_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.errors import GeodesicError, _xkwds_pop2
-from pygeodesy.fmath import hypot as _hypot
+from pygeodesy.fmath import hypot as _hypot,  Fmt
 from pygeodesy.fsums import fsumf_, fsum1f_
 from pygeodesy.geodesicx.gxbases import _cosSeries, _GeodesicBase, \
-                                        _sincos12, _sin1cos2, _xnC4
-from pygeodesy.geodesicx.gxline import _GeodesicLineExact, _TINY, _update_glXs
-from pygeodesy.interns import NN, _COMMASPACE_, _DOT_, _UNDER_
+                                        _sincos12, _sin1cos2, _sinf1cos2d, \
+                                        _TINY, _xnC4
+from pygeodesy.geodesicx.gxline import _GeodesicLineExact, _update_glXs
+from pygeodesy.interns import NN, _DOT_, _UNDER_
 from pygeodesy.karney import GDict, _around, _atan2d, Caps, _cbrt, _diff182, \
                             _fix90, _K_2_0, _norm2, _norm180, _polynomial, \
                             _signBit, _sincos2, _sincos2d, _sincos2de, _unsigned2
 from pygeodesy.lazily import _ALL_DOCS, _ALL_MODS as _MODS
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
 from pygeodesy.props import deprecated_Property, Property, Property_RO, property_RO
-from pygeodesy.streprs import Fmt, pairs
+# from pygeodesy.streprs import Fmt  # from .fmath
 from pygeodesy.utily import atan2d as _atan2d_reverse, _unrollon, _Wrap, wrap360
 
 from math import atan2, copysign, cos, degrees, fabs, radians, sqrt
 
 __all__ = ()
-__version__ = '24.05.31'
+__version__ = '24.06.24'
 
 _MAXIT1 = 20
 _MAXIT2 = 10 + _MAXIT1 + MANT_DIG  # MANT_DIG == C++ digits
@@ -553,10 +554,10 @@ class GeodesicExact(_GeodesicBase):
         # to check, e.g., on verifying quadrants in atan2.  In addition,
         # this enforces some symmetries in the results returned.
 
-        # Initialize for the meridian.  No longitude calculation is
-        # done in this case to let the parameter default to 0.
-        sbet1, cbet1 = self._sinf1cos2d(lat1)
-        sbet2, cbet2 = self._sinf1cos2d(lat2)
+        # Initialize for the meridian.  No longitude calculation is done in
+        # this case to let the parameter default to 0.
+        sbet1, cbet1 = _sinf1cos2d(lat1, self.f1)
+        sbet2, cbet2 = _sinf1cos2d(lat2, self.f1)
         # If cbet1 < -sbet1, then cbet2 - cbet1 is a sensitive measure
         # of the |bet1| - |bet2|.  Alternatively (cbet1 >= -sbet1),
         # abs(sbet2) + sbet1 is a better measure.  This logic is used
@@ -1241,27 +1242,16 @@ class GeodesicExact(_GeodesicBase):
 
     Polygon = Area  # for C{geographiclib} compatibility
 
-    def _sinf1cos2d(self, lat):
-        '''(INTERNAL) Helper, also for C{_G_GeodesicLineExact}.
-        '''
-        sbet, cbet = _sincos2d(lat)
-        # ensure cbet1 = +epsilon at poles; doing the fix on beta means
-        # that sig12 will be <= 2*tiny for two points at the same pole
-        sbet, cbet = _norm2(sbet * self.f1, cbet)
-        return sbet, (cbet if fabs(cbet) > _TINY else _TINY)
-
-    def toStr(self, prec=6, sep=_COMMASPACE_, **unused):  # PYCHOK signature
+    def toStr(self, **prec_sep_name):  # PYCHOK signature
         '''Return this C{GeodesicExact} as string.
 
-           @kwarg prec: The C{float} precision, number of decimal digits (0..9).
-                        Trailing zero decimals are stripped for B{C{prec}} values
-                        of 1 and above, but kept for negative B{C{prec}} values.
-           @kwarg sep: Separator to join (C{str}).
+           @see: L{Ellipsoid.toStr<pygeodesy.ellipsoids.Ellipsoid.toStr>}
+                 for further details.
 
-           @return: Tuple items (C{str}).
+           @return: C{GeodesicExact} (C{str}).
         '''
-        d = dict(ellipsoid=self.ellipsoid, C4order=self.C4order)
-        return sep.join(pairs(d, prec=prec))
+        return self._instr(props=(GeodesicExact.ellipsoid,),
+                           C4order=self.C4order, **prec_sep_name)
 
 
 class GeodesicLineExact(_GeodesicLineExact):
@@ -1290,7 +1280,7 @@ class GeodesicLineExact(_GeodesicLineExact):
         '''
         _xinstanceof(GeodesicExact, geodesic=geodesic)
         if (caps & Caps.LINE_OFF):  # copy to avoid updates
-            geodesic = geodesic.copy(deep=False, name=_UNDER_(NN, geodesic.name))  # NOT _under!
+            geodesic = geodesic.copy(deep=False, name=_UNDER_(NN, geodesic.name))
 #           _update_all(geodesic)
         _GeodesicLineExact.__init__(self, geodesic, lat1, lon1, azi1, caps, 0, **name)
 

pygeodesy/geodesicx/gxbases.py

@@ -9,19 +9,21 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 '''
 
 from pygeodesy.basics import isodd,  _MODS
-from pygeodesy.constants import _0_0, _100_0
+from pygeodesy.constants import _EPSmin as _TINY, _0_0, _100_0
 from pygeodesy.errors import _or, _xkwds_item2
 from pygeodesy.fmath import hypot as _hypot
-from pygeodesy.karney import _CapsBase, GeodesicError, _2cos2x, _sum2_
+from pygeodesy.karney import _CapsBase, GeodesicError, _2cos2x, \
+                             _norm2, _sincos2d, _sum2_
 # from pygeodesy.lazily import _MODS, printf  # .basics, _MODS
 
-from math import ldexp as _ldexp
+from math import fabs, ldexp as _ldexp
 
 __all__ = ()
-__version__ = '24.05.19'
+__version__ = '24.06.16'
 
 # valid C{nC4}s and C{C4order}s, see _xnC4 below
 _nC4s = {24: 2900, 27: 4032, 30: 5425}
+# assert (_TINY * EPS) > 0 and (_TINY + EPS) == EPS  # underflow guard
 
 
 class _GeodesicBase(_CapsBase):  # in .geodsolve
@@ -71,15 +73,15 @@ def _cosSeries(c4s, sx, cx):  # PYCHOK shared .geodesicx.gx and -.gxline
     y0  =  t0 = y1 = t1 = _0_0
     c4  =  list(c4s)
     _c4 =  c4.pop
-    _s2 = _sum2_
     if isodd(len(c4)):
         y0 = _c4()
+    _s2 = _sum2_
     while c4:
         # y1 = ar * y0 - y1 + c4.pop()
         # y0 = ar * y1 - y0 + c4.pop()
         y1, t1 = _s2(ar * y0, ar * t0, -y1, -t1, _c4())
         y0, t0 = _s2(ar * y1, ar * t1, -y0, -t0, _c4())
-    # s  = cx * (y0 - y1)
+    # s  = (y0 - y1) * cx
     s, _ = _s2(cx * y0, _0_0, cx * t0, -cx * y1, -cx * t1)
     return s
 
@@ -93,7 +95,7 @@ def _f2(hi, lo):  # in .geodesicx._C4_24, _27 and _30
     return _ldexp(_f(hi), 52) + _f(lo)
 
 
-def _sincos12(sin1, cos1, sin2, cos2, sineg0=False):  # PYCHOK shared
+def _sincos12(sin1, cos1, sin2, cos2, sineg0=False):
     '''(INTERNAL) Compute the sine and cosine of angle
        M{ang12 = atan2(sin2, cos2) - atan2(sin1, cos1)}.
 
@@ -111,7 +113,7 @@ def _sincos12(sin1, cos1, sin2, cos2, sineg0=False):  # PYCHOK shared
     return s, c
 
 
-def _sin1cos2(sin1, cos1, sin2, cos2):  # PYCHOK shared
+def _sin1cos2(sin1, cos1, sin2, cos2):
     '''(INTERNAL) Compute the C{sin1 * cos2} sine and its cosine.
 
        @return: 2-Tuple C{(sin1 * cos2, hypot(sin1 * sin2, cos1)}.
@@ -121,6 +123,16 @@ def _sin1cos2(sin1, cos1, sin2, cos2):  # PYCHOK shared
     return s, c  # _norm2(s, c)
 
 
+def _sinf1cos2d(lat, f1):
+    '''(INTERNAL) See C{GeodesicExact} and C{_GeodesicLineExact}.
+    '''
+    sbet, cbet = _sincos2d(lat)
+    # ensure cbet1 = +epsilon at poles; doing the fix on beta means
+    # that sig12 will be <= 2*tiny for two points at the same pole
+    sbet, cbet = _norm2(sbet * f1, cbet)
+    return sbet, (cbet if fabs(cbet) > _TINY else _TINY)
+
+
 def _xnC4(**name_nC4):
     '''(INTERNAL) Validate C{C4order}.
     '''

pygeodesy/geodesicx/gxline.py

@@ -37,30 +37,27 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 # - s and c prefixes mean sin and cos
 
 # from pygeodesy.basics import _xinstanceof  # _MODS
-from pygeodesy.constants import NAN, _EPSmin, _EPSqrt as _TOL, _0_0, \
-                               _1_0, _180_0, _2__PI, _copysign_1_0
-from pygeodesy.errors import _xError,  _COMMASPACE_
+from pygeodesy.constants import NAN, _EPSqrt as _TOL, _0_0, _1_0, \
+                               _180_0, _2__PI, _copysign_1_0
+# from pygeodesy.errors import _xError  # _MODS
 from pygeodesy.fsums import fsumf_, fsum1f_
 from pygeodesy.geodesicx.gxbases import _cosSeries, _GeodesicBase, \
-                                        _sincos12, _sin1cos2
+                                        _sincos12, _sin1cos2, \
+                                        _sinf1cos2d, _TINY
 # from pygeodesy.geodesicw import _Intersecant2  # _MODS
-# from pygeodesy.interns import _COMMASPACE_  # from .errors
 from pygeodesy.lazily import _ALL_DOCS, _ALL_MODS as _MODS
 from pygeodesy.karney import _around, _atan2d, Caps, GDict, _fix90, \
                              _K_2_0, _norm2, _norm180, _sincos2, _sincos2d
-from pygeodesy.props import Property_RO, _update_all
-# from pygeodesy.streprs import pairs  # _MODS
+from pygeodesy.named import Property_RO, _update_all
+# from pygeodesy.props import Property_RO, _update_all  # from .named
 from pygeodesy.utily import atan2d as _atan2d_reverse, sincos2
 
 from math import atan2, cos, degrees, fabs, floor, radians, sin
 
 __all__ = ()
-__version__ = '24.05.19'
+__version__ = '24.06.24'
 
 _glXs = []  # instances of C{[_]GeodesicLineExact} to be updated
-# underflow guard, we require _TINY * EPS > 0, _TINY + EPS == EPS
-_TINY = _EPSmin
-# assert (_TINY * EPS) > 0 and (_TINY + EPS) == EPS
 
 
 def _update_glXs(gX):  # see GeodesicExact.C4order and -._ef_reset_k2
@@ -122,7 +119,7 @@ class _GeodesicLineExact(_GeodesicBase):
         # allow lat, azimuth and unrolling of lon
         self._caps  = caps | Cs._LINE
 
-        sbet1, cbet1 = gX._sinf1cos2d(_around(lat1))
+        sbet1, cbet1 = _sinf1cos2d(_around(lat1), gX.f1)
         self._dn1 = gX._dn(sbet1, cbet1)
         # Evaluate alp0 from sin(alp1) * cos(bet1) = sin(alp0), with alp0
         # in [0, pi/2 - |bet1|].  Alt: calp0 = hypot(sbet1, calp1 * cbet1),
@@ -501,7 +498,7 @@ class _GeodesicLineExact(_GeodesicBase):
         try:
             return _MODS.geodesicw._Intersecant2(self, lat0, lon0, radius, tol=tol)
         except (TypeError, ValueError) as x:
-            raise _xError(x, lat0, lon0, radius, tol=_TOL)
+            raise _MODS.errors._xError(x, lat0, lon0, radius, tol=_TOL)
 
     @Property_RO
     def _H0e2_f1(self):
@@ -626,20 +623,17 @@ class _GeodesicLineExact(_GeodesicBase):
         # unnecessary because Einv inverts E
         # return -self._eF.deltaEinv(stau1, ctau1)
 
-    def toStr(self, prec=6, sep=_COMMASPACE_, **unused):  # PYCHOK signature
+    def toStr(self, **prec_sep_name):  # PYCHOK signature
         '''Return this C{GeodesicLineExact} as string.
 
-           @kwarg prec: The C{float} precision, number of decimal digits (0..9).
-                        Trailing zero decimals are stripped for B{C{prec}} values
-                        of 1 and above, but kept for negative B{C{prec}} values.
-           @kwarg sep: Separator to join (C{str}).
+           @see: L{Ellipsoid.toStr<pygeodesy.ellipsoids.Ellipsoid.toStr>}
+                 for further details.
 
            @return: C{GeodesicLineExact} (C{str}).
         '''
-        d = dict(geodesic=self.geodesic,
-                 lat1=self.lat1, lon1=self.lon1, azi1=self.azi1,
-                 a13=self.a13, s13=self.s13)
-        return sep.join(_MODS.streprs.pairs(d, prec=prec))
+        C = _GeodesicLineExact
+        t =  C.lat1, C.lon1, C.azi1, C.a13, C.s13, C.geodesic
+        return self._instr(props=t, **prec_sep_name)
 
 
 __all__ += _ALL_DOCS(_GeodesicLineExact)

pygeodesy/geodsolve.py

@@ -10,30 +10,32 @@ of the C{GeodSolve} executable.
 '''
 
 from pygeodesy.basics import _xinstanceof
+# from pygeodesy.constants import NAN, _0_0 # from .karney
 # from pygeodesy.geodesicx import GeodesicAreaExact  # _MODS
 from pygeodesy.interns import NN, _a12_, _azi1_, _azi2_, \
                              _lat1_, _lat2_, _lon1_, _lon2_, _m12_, \
                              _M12_, _M21_, _s12_, _S12_, _UNDER_
 from pygeodesy.interns import _UNUSED_, _not_  # PYCHOK used!
 from pygeodesy.karney import _Azi, Caps, _Deg, GeodesicError, _GTuple, \
-                             _Pass, _Lat, _Lon, _M, _M2, _sincos2d
+                             _Pass, _Lat, _Lon, _M, _M2, _sincos2d, \
+                             _0_0, NAN
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, \
                              _getenv, _PYGEODESY_GEODSOLVE_
 from pygeodesy.named import _name1__
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
-from pygeodesy.props import Property, Property_RO
+from pygeodesy.props import Property, Property_RO, property_RO
 from pygeodesy.solveBase import _SolveBase, _SolveLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.06.04'
+__version__ = '24.06.26'
 
 
 class GeodSolve12Tuple(_GTuple):
     '''12-Tuple C{(lat1, lon1, azi1, lat2, lon2, azi2, s12, a12, m12, M12, M21, S12)} with
        angles C{lat1}, C{lon1}, C{azi1}, C{lat2}, C{lon2} and C{azi2} and arc C{a12} all in
        C{degrees}, initial C{azi1} and final C{azi2} forward azimuths, distance C{s12} and
-       reduced length C{m12} in C{meter}, area C{S12} in C{meter} I{squared}  and geodesic
+       reduced length C{m12} in C{meter}, area C{S12} in C{meter} I{squared} and geodesic
        scale factors C{M12} and C{M21}, both C{scalar}, see U{GeodSolve
        <https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}.
     '''
@@ -222,8 +224,11 @@ class GeodesicSolve(_GeodesicSolveBase):
                  <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicExact.html>} and
                  Python U{Geodesic.InverseLine<https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
         '''
-        r = self.Inverse(lat1, lon1, lat2, lon2)
-        return GeodesicLineSolve(self, lat1, lon1, r.azi1, **_name1__(caps_name, _or_nameof=self))
+        r  = self.Inverse(lat1, lon1, lat2, lon2)
+        gl = GeodesicLineSolve(self, lat1, lon1, r.azi1, **_name1__(caps_name, _or_nameof=self))
+        gl._a13 = r.a12  # gl.SetArc(r.a12)
+        gl._s13 = r.s12  # gl.SetDistance(r.s12)
+        return gl
 
 
 class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
@@ -237,6 +242,8 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
        @note: This C{geodesic} is intended I{for testing purposes only}, it invokes the C{GeodSolve}
               executable for I{every} method call.
     '''
+    _a13 = \
+    _s13 = NAN  # see GeodesicSolve._InverseLine
 
     def __init__(self, geodesic, lat1, lon1, azi1, caps=Caps.ALL, **name):
         '''New L{GeodesicLineSolve} instance, allowing points to be found along
@@ -268,7 +275,22 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
         except GeodesicError:
             pass
 
-    def ArcPosition(self, a12, outmask=_UNUSED_):  # PYCHOK unused
+    @Property_RO
+    def a13(self):
+        '''Get the arc length to reference point 3 (C{degrees}).
+
+           @see: Methods L{Arc} and L{SetArc}.
+        '''
+        return self._a13
+
+    def Arc(self):
+        '''Return the arc length to reference point 3 (C{degrees} or C{NAN}).
+
+           @see: Method L{SetArc} and property L{a13}.
+        '''
+        return self.a13
+
+    def ArcPosition(self, a12, outmask=Caps.STANDARD):  # PYCHOK unused
         '''Find the position on the line given B{C{a12}}.
 
            @arg a12: Spherical arc length from the first point to the
@@ -277,7 +299,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
            @return: A C{GDict} with 12 items C{lat1, lon1, azi1, lat2, lon2,
                     azi2, m12, a12, s12, M12, M21, S12}.
         '''
-        return self._GDictInvoke(self._cmdArc, True, self._Names_Direct, a12)
+        return self._GDictInvoke(self._cmdArc, True, self._Names_Direct, a12)._unCaps(outmask)
 
     @Property_RO
     def azi1(self):
@@ -301,6 +323,17 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
         '''
         return self._cmdDistance + ('-a',)
 
+    def Distance(self):
+        '''Return the distance to reference point 3 (C{meter} or C{NAN}).
+        '''
+        return self.s13
+
+    @property_RO
+    def geodesic(self):
+        '''Get the geodesic (L{GeodesicSolve}).
+        '''
+        return self._solve  # see .solveBase._SolveLineBase
+
     def Intersecant2(self, lat0, lon0, radius, **kwds):  # PYCHOK no cover
         '''B{Not implemented}, throws a C{NotImplementedError} always.'''
         self._notImplemented(lat0, lon0, radius, **kwds)
@@ -309,7 +342,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
         '''B{Not implemented}, throws a C{NotImplementedError} always.'''
         self._notImplemented(lat0, lon0, **kwds)
 
-    def Position(self, s12, outmask=_UNUSED_):  # PYCHOK unused
+    def Position(self, s12, outmask=Caps.STANDARD):
         '''Find the position on the line given B{C{s12}}.
 
            @arg s12: Distance from the first point to the second (C{meter}).
@@ -317,7 +350,44 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
            @return: A C{GDict} with 12 items C{lat1, lon1, azi1, lat2, lon2,
                     azi2, m12, a12, s12, M12, M21, S12}, possibly C{a12=NAN}.
         '''
-        return self._GDictInvoke(self._cmdDistance, True, self._Names_Direct, s12)
+        return self._GDictInvoke(self._cmdDistance, True, self._Names_Direct, s12)._unCaps(outmask)
+
+    @Property_RO
+    def s13(self):
+        '''Get the distance to reference point 3 (C{meter} or C{NAN}).
+
+           @see: Methods L{Distance} and L{SetDistance}.
+        '''
+        return self._s13
+
+    def SetArc(self, a13):
+        '''Set reference point 3 in terms relative to the first point.
+
+           @arg a13: Spherical arc length from the first to the reference
+                     point (C{degrees}).
+
+           @return: The distance C{s13} (C{meter}) between the first and
+                    the reference point or C{NAN}.
+        '''
+        if self._a13 != a13:
+            self._a13 = a13
+            self._s13 = self.ArcPosition(a13, outmask=Caps.DISTANCE).s12  # if a13 else _0_0
+#           _update_all(self)
+        return self._s13
+
+    def SetDistance(self, s13):
+        '''Set reference point 3 in terms relative to the first point.
+
+           @arg s13: Distance from the first to the reference point (C{meter}).
+
+           @return: The arc length C{a13} (C{degrees}) between the first
+                    and the reference point or C{NAN}.
+        '''
+        if self._s13 != s13:
+            self._s13 = s13
+            self._a13 = self.Position(s13, outmask=Caps.DISTANCE).a12 if s13 else _0_0
+#           _update_all(self)
+        return self._a13  # NAN for GeodesicLineExact without Cap.DISTANCE_IN
 
     def toStr(self, **prec_sep):  # PYCHOK signature
         '''Return this C{GeodesicLineSolve} as string.

pygeodesy/geohash.py

@@ -20,7 +20,7 @@ from pygeodesy.basics import isodd, isstr, map2
 from pygeodesy.constants import EPS, R_M, _floatuple, _0_0, _0_5, _180_0, \
                                _360_0,  _90_0, _N_90_0, _N_180_0  # PYCHOK used!
 from pygeodesy.dms import parse3llh  # parseDMS2
-from pygeodesy.errors import _ValueError, _xkwds
+from pygeodesy.errors import _ValueError, _xkwds, _xStrError
 from pygeodesy.fmath import favg
 # from pygeodesy import formy as _formy  # _MODS
 from pygeodesy.interns import NN, _COMMA_, _DOT_, _E_, _N_, _NE_, _NW_, \
@@ -32,13 +32,12 @@ from pygeodesy.namedTuples import Bounds2Tuple, Bounds4Tuple, LatLon2Tuple, \
 from pygeodesy.props import deprecated_function, deprecated_method, \
                             deprecated_property_RO, Property_RO
 from pygeodesy.streprs import fstr
-from pygeodesy.units import Degrees_, Int, Lat, Lon, Precision_, Str, \
-                           _xStrError
+from pygeodesy.units import Degrees_, Int, Lat, Lon, Precision_, Str
 
 from math import fabs, ldexp, log10, radians
 
 __all__ = _ALL_LAZY.geohash
-__version__ = '24.06.10'
+__version__ = '24.06.15'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -237,7 +236,7 @@ class Geohash(Str):
            @kwarg LatLon: Optional class to return I{bounds} (C{LatLon})
                           or C{None}.
            @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                               arguments, ignored if B{C{LatLon}} is C{None}.
+                               arguments, ignored if C{B{LatLon} is None}.
 
            @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)} of B{C{LatLon}}s
                     or a L{Bounds4Tuple}C{(latS, lonW, latN, lonE)} if
@@ -300,16 +299,15 @@ class Geohash(Str):
 
            @arg other: The other geohash (L{Geohash}, C{LatLon} or C{str}).
            @kwarg radius: Mean earth radius, ellipsoid or datum (C{meter},
-                          L{Ellipsoid}, L{Ellipsoid2}, L{Datum} or
-                          L{a_f2Tuple}) or C{None}, see function
-                          L{pygeodesy.equirectangular}.
+                          L{Ellipsoid}, L{Ellipsoid2}, L{Datum} or L{a_f2Tuple})
+                          or C{None}, see function L{pygeodesy.equirectangular}.
            @kwarg adjust_limit_wrap: Optional keyword arguments for function
                          L{pygeodesy.equirectangular4}, overriding defaults
                          C{B{adjust}=False, B{limit}=None} and C{B{wrap}=False}.
 
-           @return: Distance (C{meter}, same units as B{C{radius}} or the
-                    ellipsoid or datum axes or C{radians I{squared}} if
-                    B{C{radius}} is C{None} or C{0}).
+           @return: Distance (C{meter}, same units as B{C{radius}} or the ellipsoid
+                    or datum axes or C{radians I{squared}} if B{C{radius} is None}
+                    or C{0}).
 
            @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon} or
                              C{str} or invalid B{C{radius}}.
@@ -398,13 +396,11 @@ class Geohash(Str):
            as an instance of the supplied C{LatLon} class.
 
            @arg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}}
-                               keyword arguments, ignored if
-                               C{B{LatLon} is None}.
+           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
+                               arguments, ignored if C{B{LatLon} is None}.
 
-           @return: This geohash location (B{C{LatLon}}) or a
-                    L{LatLon2Tuple}C{(lat, lon)} if B{C{LatLon}}
-                    is C{None}.
+           @return: This geohash location (B{C{LatLon}}) or if C{B{LatLon}
+                    is None}, a L{LatLon2Tuple}C{(lat, lon)}.
 
            @raise TypeError: Invalid B{C{LatLon}} or B{C{LatLon_kwds}}.
         '''
@@ -500,19 +496,17 @@ _Neighbors8Defaults = dict(zip(Neighbors8Dict._Keys_, (None,) *
 def bounds(geohash, LatLon=None, **LatLon_kwds):
     '''Returns the lower-left SW and upper-right NE corners of a geohash.
 
-       @arg geohash: To be bound (L{Geohash}).
-       @kwarg LatLon: Optional class to return the bounds (C{LatLon})
-                      or C{None}.
-       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                           arguments, ignored if C{B{LatLon} is None}.
+       @arg geohash: To be "bound" (L{Geohash}).
+       @kwarg LatLon: Optional class to return the bounds (C{LatLon}) or C{None}.
+       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
+                           ignored if C{B{LatLon} is None}.
 
-       @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)} of B{C{LatLon}}s
-                or if B{C{LatLon}} is C{None}, a L{Bounds4Tuple}C{(latS,
-                lonW, latN, lonE)}.
+       @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)}, each a B{C{LatLon}}
+                or if C{B{LatLon} is None}, a L{Bounds4Tuple}C{(latS, lonW,
+                latN, lonE)}.
 
-       @raise TypeError: The B{C{geohash}} is not a L{Geohash}, C{LatLon}
-                         or C{str} or invalid B{C{LatLon}} or invalid
-                         B{C{LatLon_kwds}}.
+       @raise TypeError: The B{C{geohash}} is not a L{Geohash}, C{LatLon} or
+                         C{str} or invalid B{C{LatLon}} or invalid B{C{LatLon_kwds}}.
 
        @raise GeohashError: Invalid or C{null} B{C{geohash}}.
     '''
@@ -847,14 +841,12 @@ def resolution2(prec1, prec2=None):
 def sizes(geohash):
     '''Return the lat- and longitudinal size of this L{Geohash} cell.
 
-       @arg geohash: Cell for which size are required (L{Geohash} or
-                     C{str}).
+       @arg geohash: Cell for which size are required (L{Geohash} or C{str}).
 
-       @return: A L{LatLon2Tuple}C{(lat, lon)} with the latitudinal
-                height and longitudinal width in (C{meter}).
+       @return: A L{LatLon2Tuple}C{(lat, lon)} with the latitudinal height and
+                longitudinal width in (C{meter}).
 
-       @raise TypeError: The B{C{geohash}} is not a L{Geohash},
-                         C{LatLon} or C{str}.
+       @raise TypeError: The B{C{geohash}} is not a L{Geohash}, C{LatLon} or C{str}.
     '''
     return _2Geohash(geohash).sizes