pygeodesy 24.6.1__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.05.31'
+__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>}.
     '''
@@ -59,11 +61,11 @@ class _GeodesicSolveBase(_SolveBase):
     def _cmdBasic(self):
         '''(INTERNAL) Get the basic C{GeodSolve} cmd (C{tuple}).
         '''
-        return (self.GeodSolve,) + self._b_option \
-                                 + self._e_option \
-                                 + self._E_option \
-                                 + self._p_option \
-                                 + self._u_option + ('-f',)
+        return (self.GeodSolve, '-f') + (self._b_option +
+                                         self._e_option +
+                                         self._E_option +
+                                         self._p_option +
+                                         self._u_option)
 
     @Property_RO
     def _E_option(self):
@@ -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.
@@ -362,49 +432,47 @@ if __name__ == '__main__':
     p = glS.ArcPosition(49.475527)
     printf('ArcPosition: %s %r', p == r, p)
 
-# % python3 -m pygeodesy.geodsolve
 
-# version: /opt/local/bin/GeodSolve: GeographicLib version 1.51
+# % python3 -m pygeodesy.geodsolve
 
-# version: /opt/local/bin/GeodSolve: GeographicLib version 1.51
+# version: /opt/local/bin/GeodSolve: GeographicLib version 2.2
 
-# Direct: GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
+# Direct: GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
 # Direct3: Destination3Tuple(lat=51.884565, lon=-1.141173, final=107.189397)
 
-# Inverse: GDict(M12=0.64473, M21=0.645046, S12=40041368848742.53125, a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, s12=5551759.400319)
+# Inverse: GDict(a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, M12=0.64473, M21=0.645046, s12=5551759.400319, S12=40041368848742.53125)
 # Inverse1: 49.94131021789904
 # Inverse3: Distance3Tuple(distance=5551759.400319, initial=51.198883, final=107.821777)
 
-# Position:    True  GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
-# ArcPosition: False GDict(M12=0.650911, M21=0.651229, S12=39735074737272.734375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, s12=5499999.948497)
+# Position:    True  GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
+# ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, M12=0.650911, M21=0.651229, s12=5499999.948497, S12=39735074737272.734375)
 
 
 # % python3 -m pygeodesy.geodsolve --verbose
 
 # GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve --version (invoke)
-# GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve: GeographicLib version 1.51 (0)
-# version: /opt/local/bin/GeodSolve: GeographicLib version 1.51
-# GeodesicSolve 'Test' 2: /opt/local/bin/GeodSolve -E -p 10 -f \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct)
+# GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve: GeographicLib version 2.2 (0)
+# version: /opt/local/bin/GeodSolve: GeographicLib version 2.2
+# GeodesicSolve 'Test' 2: /opt/local/bin/GeodSolve -f -E -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct)
 # GeodesicSolve 'Test' 2: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.0, lat2=51.884564505606761, lon2=-1.141172861200829, azi2=107.189397162605886, s12=5500000.0, a12=49.475527463251467, m12=4844148.703101486, M12=0.65091056699808603, M21=0.65122865892196558, S12=39735075134877.094 (0)
 
-# Direct: GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
-# GeodesicSolve 'Test' 3: /opt/local/bin/GeodSolve -E -p 10 -f \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct3)
+# Direct: GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
+# GeodesicSolve 'Test' 3: /opt/local/bin/GeodSolve -f -E -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct3)
 # GeodesicSolve 'Test' 3: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.0, lat2=51.884564505606761, lon2=-1.141172861200829, azi2=107.189397162605886, s12=5500000.0, a12=49.475527463251467, m12=4844148.703101486, M12=0.65091056699808603, M21=0.65122865892196558, S12=39735075134877.094 (0)
 # Direct3: Destination3Tuple(lat=51.884565, lon=-1.141173, final=107.189397)
-# GeodesicSolve 'Test' 4: /opt/local/bin/GeodSolve -E -p 10 -f -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse)
+# GeodesicSolve 'Test' 4: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse)
 # GeodesicSolve 'Test' 4: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186841, a12=49.941310217899037, m12=4877684.6027061976, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
 
-# Inverse: GDict(M12=0.64473, M21=0.645046, S12=40041368848742.53125, a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, s12=5551759.400319)
-# GeodesicSolve 'Test' 5: /opt/local/bin/GeodSolve -E -p 10 -f -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
+# Inverse: GDict(a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, M12=0.64473, M21=0.645046, s12=5551759.400319, S12=40041368848742.53125)
+# GeodesicSolve 'Test' 5: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
 # GeodesicSolve 'Test' 5: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186841, a12=49.941310217899037, m12=4877684.6027061976, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
 # Inverse1: 49.94131021789904
-# GeodesicSolve 'Test' 6: /opt/local/bin/GeodSolve -E -p 10 -f -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
+# GeodesicSolve 'Test' 6: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
 # GeodesicSolve 'Test' 6: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186841, a12=49.941310217899037, m12=4877684.6027061976, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
 # Inverse3: Distance3Tuple(distance=5551759.400319, initial=51.198883, final=107.821777)
 
-# Position:    True  GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
-# ArcPosition: False GDict(M12=0.650911, M21=0.651229, S12=39735074737272.734375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, s12=5499999.948497)
-
+# Position:    True  GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
+# ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, M12=0.650911, M21=0.651229, s12=5499999.948497, S12=39735074737272.734375)
 
 # **) MIT License
 #