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

pygeodesy/geodesicx/gxline.py

@@ -37,30 +37,28 @@ 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, isfinite
+from pygeodesy.errors import _xError, _xkwds_pop2
 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
+                             _K_2_0, _llz2line, _norm2, _norm180, \
+                             _sincos2, _sincos2d
+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.07.09'
 
 _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
@@ -95,23 +93,18 @@ class _GeodesicLineExact(_GeodesicBase):
 #   _somg1 = _comg1 = NAN
 #   _ssig1 = _csig1 = NAN
 
-    def __init__(self, gX, lat1, lon1, azi1, caps, _debug, *salp1_calp1, **name):
+    def __init__(self, gX, lat1, lon1, azi1, caps, **name_):
         '''(INTERNAL) New C{[_]GeodesicLineExact} instance.
         '''
-        _xGeodesicExact(gX=gX)
-        Cs = Caps
-        if _debug:  # PYCHOK no cover
-            self._debug |= _debug & Cs._DEBUG_ALL
-            # _CapsBase.debug._update(self)
-        if salp1_calp1:
-            salp1, calp1 = salp1_calp1
-        else:
+#       _xGeodesicExact(gX=gX)
+        if azi1 is None:  # see GeodesicExact.InverseLine
+            (salp1, calp1), name_ = _xkwds_pop2(name_, _s_calp1=(_0_0, _1_0))
+            azi1 = _atan2d(salp1, calp1)
+        else:  # guard against salp0 underflow, convert -0 to +0
             azi1 = _norm180(azi1)
-            # guard against salp0 underflow,
-            # also -0 is converted to +0
             salp1, calp1 = _sincos2d(_around(azi1))
-        if name:
-            self.name = name
+        if name_:
+            self.name = name_
 
         self._gX    = gX  # GeodesicExact only
         self._lat1  = lat1 = _fix90(lat1)
@@ -120,9 +113,9 @@ class _GeodesicLineExact(_GeodesicBase):
         self._salp1 = salp1
         self._calp1 = calp1
         # allow lat, azimuth and unrolling of lon
-        self._caps  = caps | Cs._LINE
+        self._caps  = caps | Caps._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),
@@ -145,11 +138,11 @@ class _GeodesicLineExact(_GeodesicBase):
         self._ssig1, self._csig1 = _norm2(sbet1, c)  # sig1 in (-pi, pi]
         # _norm2(somg1, comg1)  # no need to normalize!
         # _norm2(schi1?, cchi1)  # no need to normalize!
-        if not (caps & Cs.LINE_OFF):
+        if not (caps & Caps.LINE_OFF):
             _glXs.append(self)
         # no need to pre-compute other attrs based on _Caps.X.  All are
-        # Property_RO's, computed once and cached/memoized until reset
-        # when C4order is changed or Elliptic function reset is invoked.
+        # Property_RO's, computed once and cached/memoized until reset when
+        # arc, distance, C4order is changed or Elliptic function is reset.
 
     def __del__(self):  # XXX use weakref?
         if _glXs:  # may be empty or None
@@ -298,22 +291,18 @@ class _GeodesicLineExact(_GeodesicBase):
                     C{lon1}, C{azi1} and arc length C{a12} always included,
                     except when C{a12=NAN}.
         '''
-
-        r = GDict(a12=NAN, s12=NAN)  # note both a12 and s12, always
-        if not (arcmode or self._caps_DISTANCE_IN):  # PYCHOK no cover
-            return r  # Uninitialized or impossible distance requested
-
         Cs = Caps
-        if self._debug:  # PYCHOK no cover
-            outmask |= self._debug & Cs._DEBUG_DIRECT_LINE
-        outmask &= self._caps & Cs._OUT_MASK
-
+        if outmask:
+            outmask &= self._caps & Cs._OUT_MASK
         eF = self._eF
         gX = self.geodesic  # ._gX
+        r  = GDict(a12=NAN, s12=NAN)  # both a12 and s12, always
 
-        if arcmode:
-            # s12_a12 is spherical arc length
-            E2 = _0_0
+        if not isfinite(s12_a12):
+            # E2 = sig12 = ssig12 = csig12 = NAN
+            return r._toNAN(outmask)
+        elif arcmode:  # s12_a12 is (spherical) arc length
+            r.set_(a12=s12_a12)
             sig12 = radians(s12_a12)
             if _K_2_0:
                 ssig12, csig12 = sincos2(sig12)  # utily, no NEG0
@@ -322,31 +311,25 @@ class _GeodesicLineExact(_GeodesicBase):
                 a -= floor(a / _180_0) * _180_0  # 0 <= 0 < 180
                 ssig12 = _0_0 if a ==  0 else sin(sig12)
                 csig12 = _0_0 if a == 90 else cos(sig12)
-        else:  # s12_a12 is distance
+            E2 = _0_0
+        elif self._caps_DISTANCE_IN:  # s12_a12 is distance
             t = s12_a12 / self._E0b
             s, c = _sincos2(t)  # tau12
             # tau2 = tau1 + tau12
             E2 = -eF.deltaEinv(*_sincos12(-s, c, *self._stau1_ctau1))
             sig12 = fsum1f_(self._E1, -E2, t)  # == t - (E2 - E1)
             ssig12, csig12 = _sincos2(sig12)
-
-        salp0, calp0 = self._salp0, self._calp0
-        ssig1, csig1 = self._ssig1, self._csig1
+            r.set_(a12=degrees(sig12))
+        else:  # uninitialized or impossible distance requested
+            return r
 
         # sig2 = sig1 + sig12
-        ssig2, csig2 = _sincos12(-ssig12, csig12, ssig1, csig1)
-        dn2 = eF.fDelta(ssig2, csig2)
-        # sin(bet2) = cos(alp0) * sin(sig2) and
-        #    cbet2  = hypot(salp0, calp0 * csig2).  Alt:
-        #    cbet2  = hypot(csig2, salp0 * ssig2)
-        sbet2, cbet2 = _sin1cos2(calp0, salp0, csig2, ssig2)
-        if cbet2 == 0:  # salp0 = 0, csig2 = 0, break degeneracy
-            cbet2 = csig2 = _TINY
-        # tan(alp0) = cos(sig2) * tan(alp2)
-        salp2 = salp0
-        calp2 = calp0 * csig2  # no need to normalize
+        ssig1, csig1 =      self._ssig1, self._csig1
+        ssig2, csig2 = t = _sincos12(-ssig12, csig12, ssig1, csig1)
+        dn2 = eF.fDelta(*t)
 
-        if (outmask & Cs.DISTANCE):
+        if (outmask &  Cs.DISTANCE):
+            outmask ^= Cs.DISTANCE
             if arcmode:  # or f_0_01
                 E2 = eF.deltaE(ssig2, csig2, dn2)
                 # AB1 = _E0 * (E2 - _E1)
@@ -358,10 +341,34 @@ class _GeodesicLineExact(_GeodesicBase):
                 s12 = s12_a12
             r.set_(s12=s12)
 
+        if not outmask:  # all done, see ._GenSet
+            return r
+
+        if self._debug:  # PYCHOK no cover
+            outmask |= self._debug & Cs._DEBUG_DIRECT_LINE
+
         if (outmask & Cs._DEBUG_DIRECT_LINE):  # PYCHOK no cover
             r.set_(sig12=sig12, dn2=dn2, b=gX.b, e2=gX.e2, f1=gX.f1,
                    E0b=self._E0b, E1=self._E1, E2=E2, eFk2=eF.k2, eFa2=eF.alpha2)
 
+        # sin(bet2) = cos(alp0) * sin(sig2) and
+        #    cbet2  = hypot(salp0, calp0 * csig2).  Alt:
+        #    cbet2  = hypot(csig2, salp0 * ssig2)
+        salp0, calp0 =  self._salp0, self._calp0
+        sbet2, cbet2 = _sin1cos2(calp0, salp0, csig2, ssig2)
+        if cbet2 == 0:  # salp0 = 0, csig2 = 0, break degeneracy
+            cbet2 = csig2 = _TINY
+        # tan(alp0) = cos(sig2) * tan(alp2)
+        salp2 = salp0
+        calp2 = calp0 * csig2  # no need to normalize
+
+        if (outmask & Cs.AZIMUTH):
+            r.set_(azi2=_atan2d_reverse(salp2, calp2,
+                                reverse=outmask & Cs.REVERSE2))
+
+        if (outmask & Cs.LATITUDE):
+            r.set_(lat2=_atan2d(sbet2, gX.f1 * cbet2))
+
         if (outmask & Cs.LONGITUDE):
             schi1 = self._somg1
             cchi1 = self._cchi1
@@ -375,7 +382,7 @@ class _GeodesicLineExact(_GeodesicBase):
                 tchi2 = t * schi2
                 chi12 = t * fsum1f_(_a(ssig1, csig1), -_a(ssig2, csig2),
                                     _a(tchi2, cchi2), -_a(tchi1, cchi1), sig12)
-                lon2 = self.lon1 + degrees(chi12 - lam12)
+                lon2  = self.lon1 + degrees(chi12 - lam12)
             else:
                 chi12 = atan2(*_sincos12(schi1, cchi1, schi2, cchi2))
                 lon2 = _norm180(self._lon1_norm180 + _norm180(degrees(chi12 - lam12)))
@@ -384,12 +391,6 @@ class _GeodesicLineExact(_GeodesicBase):
                 r.set_(ssig2=ssig2, chi12=chi12, H0e2_f1=self._H0e2_f1,
                        csig2=csig2, lam12=lam12, H1=self._H1)
 
-        if (outmask & Cs.LATITUDE):
-            r.set_(lat2=_atan2d(sbet2, gX.f1 * cbet2))
-
-        if (outmask & Cs.AZIMUTH):
-            r.set_(azi2=_atan2d_reverse(salp2, calp2, reverse=outmask & Cs.REVERSE2))
-
         if (outmask & Cs._REDUCEDLENGTH_GEODESICSCALE):
             dn1 = self._dn1
             J12 = self._D0k2 * fsumf_(eF.deltaD(ssig2, csig2, dn2), -self._D1, sig12)
@@ -441,10 +442,9 @@ class _GeodesicLineExact(_GeodesicBase):
             S12 += gX.c2 * atan2(salp12, calp12)
             r.set_(S12=S12)
 
-        r.set_(a12=s12_a12 if arcmode else degrees(sig12),
+        r.set_(azi1=_norm180(self.azi1),
                lat1=self.lat1,  # == _fix90(lat1)
-               lon1=self.lon1 if (outmask & Cs.LONG_UNROLL) else self._lon1_norm180,
-               azi1=_norm180(self.azi1))
+               lon1=self.lon1 if (outmask & Cs.LONG_UNROLL) else self._lon1_norm180)
         return r
 
     def _GenPosition(self, arcmode, s12_a12, outmask):
@@ -456,14 +456,24 @@ class _GeodesicLineExact(_GeodesicBase):
         r = self._GDictPosition(arcmode, s12_a12, outmask)
         return r.toDirect9Tuple()
 
-    def _GenSet(self, arcmode, s13_a13):
+    def _GenSet(self, debug, s12=None, a12=None, **llz2):
         '''(INTERNAL) Aka C++ C{GenSetDistance}.
         '''
-        if arcmode:
-            self.SetArc(s13_a13)
-        else:
-            self.SetDistance(s13_a13)
-        return self  # for gx.GeodesicExact.InverseLine and -._GenDirectLine
+        Cs = Caps
+        if debug:  # PYCHOK no cover
+            self._debug |= debug & Cs._DEBUG_ALL
+            # _CapsBase.debug._update(self)
+        if s12 is None:
+            if a12 is None:  # see GeodesicExact.Line
+                return self
+            s12 = self._GDictPosition(True,  a12, outmask=Cs.DISTANCE).s12 if a12 else _0_0
+        elif a12 is None:
+            a12 = self._GDictPosition(False, s12,                   0).a12 if s12 else _0_0
+        self._s13   = s12
+        self._a13   = a12
+        self._caps |= Cs.DISTANCE | Cs.DISTANCE_IN
+        # _update_all(self)  # new, from GeodesicExact.*Line
+        return _llz2line(self, **llz2)
 
     @Property_RO
     def geodesic(self):
@@ -597,8 +607,7 @@ class _GeodesicLineExact(_GeodesicBase):
                     the reference point or C{NAN}.
         '''
         if self._a13 != a13:
-            self._a13 = a13
-            self._s13 = self._GDictPosition(True, a13, Caps.DISTANCE).s12  # if a13 else _0_0
+            self._GenSet(0, a12=a13)
             _update_all(self)
         return self._s13
 
@@ -611,10 +620,9 @@ class _GeodesicLineExact(_GeodesicBase):
                     and the reference point or C{NAN}.
         '''
         if self._s13 != s13:
-            self._s13 = s13
-            self._a13 = self._GDictPosition(False, s13, 0).a12 if s13 else _0_0
+            self._GenSet(0, s12=s13)
             _update_all(self)
-        return self._a13  # NAN for GeodesicLineExact without Cap.DISTANCE_IN
+        return self._a13
 
     @Property_RO
     def _stau1_ctau1(self):
@@ -626,20 +634,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.caps, C.geodesic
+        return self._instr(props=t, **prec_sep_name)
 
 
 __all__ += _ALL_DOCS(_GeodesicLineExact)

pygeodesy/geodsolve.py

@@ -10,46 +10,31 @@ 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
+from pygeodesy.interns import NN, _UNDER_
+from pygeodesy.karney import Caps, GeodesicError, GeodSolve12Tuple, \
+                            _llz2line, _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.solveBase import _SolveBase, _SolveLineBase
+from pygeodesy.props import Property, Property_RO, property_RO
+from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.06.04'
+__version__ = '24.07.09'
 
 
-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
-       scale factors C{M12} and C{M21}, both C{scalar}, see U{GeodSolve
-       <https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}.
-    '''
-    # from GeodSolve --help option -f ... lat1 lon1 azi1 lat2 lon2 azi2 s12 a12 m12 M12 M21 S12
-    _Names_ = (_lat1_, _lon1_, _azi1_, _lat2_, _lon2_, _azi2_, _s12_, _a12_, _m12_, _M12_, _M21_, _S12_)
-    _Units_ = (_Lat,   _Lon,   _Azi,   _Lat,   _Lon,   _Azi,   _M,    _Deg,  _Pass, _Pass, _Pass, _M2)
-
-
-class _GeodesicSolveBase(_SolveBase):
+class _GeodesicSolveBase(_SolveGDictBase):
     '''(INTERNAL) Base class for L{GeodesicSolve} and L{GeodesicLineSolve}.
     '''
     _Error         =  GeodesicError
     _Names_Direct  = \
     _Names_Inverse =  GeodSolve12Tuple._Names_
-    _Solve_name    = 'GeodSolve'
-    _Solve_path    = _getenv(_PYGEODESY_GEODSOLVE_, _PYGEODESY_GEODSOLVE_)
+    _Xable_name    = 'GeodSolve'
+    _Xable_path    = _getenv(_PYGEODESY_GEODSOLVE_, _PYGEODESY_GEODSOLVE_)
 
     @Property_RO
     def _b_option(self):
@@ -65,16 +50,12 @@ class _GeodesicSolveBase(_SolveBase):
                                          self._p_option +
                                          self._u_option)
 
-    @Property_RO
-    def _E_option(self):
-        return ('-E',) if self.Exact else ()
-
     @Property
     def GeodSolve(self):
         '''Get the U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}
            executable (C{filename}).
         '''
-        return self._Solve_path
+        return self._Xable_path
 
     @GeodSolve.setter  # PYCHOK setter!
     def GeodSolve(self, path):
@@ -84,20 +65,20 @@ class _GeodesicSolveBase(_SolveBase):
            @raise GeodesicError: Invalid B{C{path}}, B{C{path}} doesn't exist or
                                  isn't the C{GeodSolve} executable.
         '''
-        self._setSolve(path)
+        self._setXable(path)
 
     def toStr(self, **prec_sep):  # PYCHOK signature
         '''Return this C{GeodesicSolve} as string.
 
-           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=', '}
-                      for the C{float} C{prec}ision, number of decimal digits
-                      (0..9) and the C{sep}arator string to join.  Trailing
-                      zero decimals are stripped for B{C{prec}} values of
-                      1 and above, but kept for negative B{C{prec}} values.
+           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=", "}
+                       for the C{float} C{prec}ision, number of decimal digits
+                       (0..9) and the C{sep}arator string to join.  Trailing
+                       zero decimals are stripped for B{C{prec}} values of 1
+                       and above, but kept for negative B{C{prec}} values.
 
            @return: GeodesicSolve items (C{str}).
         '''
-        return _SolveBase._toStr(self, GeodSolve=self.GeodSolve, **prec_sep)
+        return _SolveGDictBase._toStr(self, GeodSolve=self.GeodSolve, **prec_sep)
 
     @Property_RO
     def _u_option(self):
@@ -117,11 +98,11 @@ class GeodesicSolve(_GeodesicSolveBase):
     '''
 
     def Area(self, polyline=False, **name):
-        '''Set up a L{GeodesicAreaExact} to compute area and
-           perimeter of a polygon.
+        '''Set up a L{GeodesicAreaExact} to compute area and perimeter
+           of a polygon.
 
-           @kwarg polyline: If C{True} perimeter only, otherwise
-                            area and perimeter (C{bool}).
+           @kwarg polyline: If C{True} perimeter only, otherwise area
+                            and perimeter (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicAreaExact} instance.
@@ -137,8 +118,8 @@ class GeodesicSolve(_GeodesicSolveBase):
     Polygon = Area  # for C{geographiclib} compatibility
 
     def Direct3(self, lat1, lon1, azi1, s12):  # PYCHOK outmask
-        '''Return the destination lat, lon and reverse azimuth
-           (final bearing) in C{degrees}.
+        '''Return the destination lat, lon and reverse azimuth (final bearing)
+           in C{degrees}.
 
            @return: L{Destination3Tuple}C{(lat, lon, final)}.
         '''
@@ -222,11 +203,14 @@ 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 _llz2line(gl, lat2=lat2, lon2=lon2, azi2=r.azi2)
 
 
-class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
+class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase):
     '''Wrapper to invoke I{Karney}'s U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}
        as an C{Exact} version of I{Karney}'s Python class U{GeodesicLine<https://GeographicLib.SourceForge.io/C++/doc/
        python/code.html#geographiclib.geodesicline.GeodesicLine>}.
@@ -237,6 +221,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
@@ -262,13 +248,28 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
         _xinstanceof(GeodesicSolve, geodesic=geodesic)
         if (caps & Caps.LINE_OFF):  # copy to avoid updates
             geodesic = geodesic.copy(deep=False, name=_UNDER_(NN, geodesic.name))  # NOT _under!
-        _SolveLineBase.__init__(self, geodesic, lat1, lon1, caps, azi1=azi1, **name)
+        _SolveGDictLineBase.__init__(self, geodesic, lat1, lon1, caps, azi1=azi1, **name)
         try:
             self.GeodSolve = geodesic.GeodSolve  # geodesic or copy of geodesic
         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 +278,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, self._Names_Direct, a12)._unCaps(outmask)
 
     @Property_RO
     def azi1(self):
@@ -301,6 +302,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 +321,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,21 +329,58 @@ 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, 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.
 
-           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=', '}
-                      for the C{float} C{prec}ision, number of decimal digits
-                      (0..9) and the C{sep}arator string to join.  Trailing
-                      zero decimals are stripped for B{C{prec}} values of
-                      1 and above, but kept for negative B{C{prec}} values.
+           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=", "}
+                       for the C{float} C{prec}ision, number of decimal digits
+                       (0..9) and the C{sep}arator string to join.  Trailing
+                       zero decimals are stripped for B{C{prec}} values of 1
+                       and above, but kept for negative B{C{prec}} values.
 
            @return: GeodesicLineSolve items (C{str}).
         '''
-        return _SolveLineBase._toStr(self, azi1=self.azi1, geodesic=self._solve,
-                                           GeodSolve=self.GeodSolve, **prec_sep)
+        return _SolveGDictLineBase._toStr(self, azi1=self.azi1, geodesic=self._solve,
+                                                GeodSolve=self.GeodSolve, **prec_sep)
 
 
 __all__ += _ALL_DOCS(_GeodesicSolveBase)
@@ -345,7 +394,7 @@ if __name__ == '__main__':
     gS.verbose = '--verbose' in argv  # or '-v' in argv
 
     if gS.GeodSolve in (_PYGEODESY_GEODSOLVE_, None):  # not set
-        gS.GeodSolve = '/opt/local/bin/GeodSolve'  # '/opt/local/Cellar/geographiclib/1.51/bin/GeodSolve'  # HomeBrew
+        gS.GeodSolve = '/opt/local/bin/GeodSolve'  # '/opt/local/Cellar/geographiclib/2.3/bin/GeodSolve'  # HomeBrew
     printf('version: %s', gS.version)
 
     r = gS.Direct(40.6, -73.8, 51, 5.5e6)