pygeodesy 25.12.31__py2.py3-none-any.whl → 26.2.2__py2.py3-none-any.whl

pygeodesy/fmath.py

@@ -22,10 +22,10 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.units import Int_, _isHeight, _isRadius
 
 from math import fabs, sqrt  # pow
-import operator as _operator  # in .datums, .trf, .utm
+import operator as _operator  # in .datums, .elliptic, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '25.12.23'
+__version__ = '26.01.06'
 
 # sqrt(2) - 1 <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ~ 3_730_904_090_310_553 / 9_007_199_254_740_992

pygeodesy/formy.py

@@ -8,28 +8,25 @@ from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _copysign, _isin  # _args_kwds_count2
 # from pygeodesy.cartesianBase import CartesianBase  # _MODS
-from pygeodesy.constants import EPS, EPS0, EPS1, EPS_2, PI, PI2, PI3, PI_2, R_M, \
+from pygeodesy.constants import EPS, EPS0, EPS1, PI, PI2, PI3, PI_2, R_M, \
                                _0_0s, float0_, isnon0, remainder, _umod_PI2, \
                                _0_0, _0_125, _0_25, _0_5, _1_0, _2_0, _4_0, \
                                _90_0, _180_0, _360_0
-from pygeodesy.constants import _3_0, _10_0, MANT_DIG as _DIG53  # PYCHOK used!
 from pygeodesy.datums import Datum, Ellipsoid, _ellipsoidal_datum, \
                             _mean_radius, _spherical_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
-# from pygeodesy.elliptic import Elliptic  # _MODS
 from pygeodesy.errors import IntersectionError, LimitError, limiterrors, \
                             _TypeError, _ValueError, _xattr, _xError, \
                             _xcallable, _xkwds, _xkwds_pop2
-from pygeodesy.fmath import euclid, fdot_, fhorner, fprod, hypot, hypot2, sqrt0
-from pygeodesy.fsums import fsum, fsumf_,  Fmt, unstr
+from pygeodesy.fmath import euclid, fdot_, fprod, hypot, hypot2, sqrt0
+from pygeodesy.fsums import fsumf_,  Fmt, unstr
 # from pygeodesy.internals import typename  # from .named
-from pygeodesy.interns import _delta_, _distant_, _DOT_, _inside_, _SPACE_, _too_
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS
-from pygeodesy.named import callername, _name__, _name2__, _NamedTuple, \
-                           _xnamed,  typename
+from pygeodesy.interns import _delta_, _distant_, _inside_, _SPACE_, _too_
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
+from pygeodesy.named import _name__, _name2__, _NamedTuple, _xnamed, \
+                             typename
 from pygeodesy.namedTuples import Bearing2Tuple, Distance4Tuple, LatLon2Tuple, \
                                   Intersection3Tuple, PhiLam2Tuple
-from pygeodesy.props import property_ROnce
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
 # from pygeodesy.triaxials.triaxial5 import _hartzell3  # _MODS
 from pygeodesy.units import _isDegrees, _isHeight, _isRadius, Bearing, Degrees_, \
@@ -46,241 +43,13 @@ from contextlib import contextmanager
 from math import atan, cos, degrees, fabs, radians, sin, sqrt  # pow
 
 __all__ = _ALL_LAZY.formy
-__version__ = '25.12.31'
+__version__ = '26.01.06'
 
 _RADIANS2 =  radians(_1_0)**2  # degree to radians-squared
 _ratio_   = 'ratio'
 _xline_   = 'xline'
 
 
-class Elliperim(object):
-    '''Singleton with various methods to compute the perimeter of an ellipse.
-    '''
-    _TOL53    =  sqrt(EPS_2)     # sqrt(pow(_0_5, _DIG53))
-    _TOL53_53 = _TOL53 / _DIG53  # "flat" b/a tolerance, 1.9e-10
-    # assert _DIG53 == 53
-
-    def AGM(self, a, b, maxit=_DIG53):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{AGM
-           <https://PaulBourke.net/geometry/ellipsecirc>} (Arithmetic-Geometric Mean) method.
-
-           @kwarg maxit: Number of iterations (C{int}).
-
-           @raise ValueError: No convergence for B{C{maxit}} iterations.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:
-            c_ = []
-            ts = self._AGMs(a, b, max(maxit, _DIG53), c_)
-            p  = fsum(ts, nonfinites=True)
-            p *= PI / c_[0]
-        return p
-
-    def _AGMs(self, a, b, maxit, c_):
-        '''(INTERNAL) Yield the C{AGM} terms and final C{c}.
-        '''
-        c = a + b
-        yield c**2
-        m = -1
-        t = self._TOL53
-        for _ in range(maxit):  # 4..5 trips
-            b  = sqrt(a * b)
-            a  = c * _0_5
-            c  = a + b
-            d  = a - b
-            m *= 2
-            yield d**2 * m
-            if d <= (b * t):
-                break
-        else:
-            raise self._Error(maxit, d, b * t)
-        c_.append(c)  # kludge
-
-    def Arc43(self, a, b):
-        '''Return the perimeter (and arcs) of an ellipse with semi-axes C{a} and C{b}
-           with the U{4-Arc<https://PaulBourke.net/geometry/ellipsecirc>} approximation.
-
-           @return: 3-Tuple C{(p, Ra, Rb)} with perimeter C{p}, arc radius C{Ra} at the
-                    major and arc radius C{Rb} at the minor semi-axis.
-        '''
-        _r, p, a, b = self._pab4(a, b)
-        if p is None:
-            h = hypot(a, b)
-            p = atan2(b, a)
-            s, c = sincos2(p)
-            L  = (h - b) * _0_5
-            Ra =  L / c
-            Rb = (h - L) / s
-            p  = Rb * p + Ra * (PI_2 - p)
-            p *= _4_0
-        else:  # circle or flat
-            Ra, Rb = a, b
-        return (p, Rb, Ra) if _r else (p, Ra, Rb)
-
-#   def CR(self, a, b):
-#       '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using U{Rackauckas'
-#          <https://www.ChrisRackauckas.com/assets/Papers/ChrisRackauckas-The_Circumference_of_an_Ellipse.pdf>}
-#          approximation, also U{here<https://ExtremeLearning.com.AU/a-formula-for-the-perimeter-of-an-ellipse>}.
-#       '''
-#       _, p, a, b = self._pab4(a, b)
-#       if p is None:
-#           p  =   a + b
-#           h  = ((a - b) / p)**2
-#           p *= (fhorner(h, 135168, -85760,  -5568, 3867) /
-#                 fhorner(h, 135168, -119552, 22208, 345)) * PI
-#       return p
-
-    def E2k(self, a, b):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} from the complete
-           elliptic integral of the 2nd kind L{E(k)<pygeodesy.elliptic.Elliptic.cE>}.
-        '''
-        return self._ellip2k(a, b, self._ellipE)
-
-    def e2k(self, a, b, E_alt=None):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using U{SciPy's
-           ellipe<https://www.JohnDCook.com/perimeter_ellipse.html>} function or method
-           C{E_alt}, otherwise C{None}.
-
-           @kwarg E_alt: An other C{Elliperim}C{(a, b)} method to use in case C{SciPy's
-                         ellipe} is not available.
-        '''
-        p = self._ellipe
-        if p is not None:  # i.e. callable
-            p = self._ellip2k(a, b, p)
-        elif callable(E_alt):  # and E_alt is not Elliperim.e2k
-            p = E_alt(a, b)
-        return p
-
-    def _ellipE(self, k):
-        '''(INTERNAL) Get the complete C{elliptic} integeral C{E(k)}.
-        '''
-        return _MODS.elliptic.Elliptic(k).cE
-
-    @property_ROnce
-    def _ellipe(self):
-        '''(INTERNAL) Wrap function C{scipy.special.ellipe}, I{once}.
-        '''
-        try:
-            from scipy.special import ellipe
-
-            def _ellipe(k):
-                return float(ellipe(k))
-
-        except (AttributeError, ImportError):
-            _ellipe = None
-        return _ellipe  # overwrite property_ROnce
-
-    def _ellip2k(self, a, b, _ellip):
-        '''(INTERNAL) Helper for methods C{E2k} and C{e2k}.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:  # see .ellipsoids.Ellipsoid.L
-            k = _1_0 - (b / a)**2
-            p = _ellip(k) * a * _4_0
-        return p
-
-    def _Error(self, maxit, d, t):
-        return _ValueError(maxit=maxit, txt=Fmt.no_convergence(d, t))
-
-    def GK(self, a, b):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{Gauss-Kummer
-           <https://www.JohnDCook.com/blog/2023/05/28/approximate-ellipse-perimeter>} series, and
-           U{here<https://www.MathsIsFun.com/geometry/ellipse-perimeter.html>}, C{B{b / a} > 0.75}.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:
-            p  =  a + b
-            h  = (a - b) / p
-            p *= fhorner(h**2, *self._GKs) * PI
-        return p
-
-    @property_ROnce
-    def _GKs(self):
-        '''(INTERNAL) Compute the Gauss-Kummer coefficients, I{once}.
-        '''
-        return (1, 1 / 4, 1 / 64, 1 / 256, 25 / 16384, 49 / 65536,
-                441 / 1048576, 1089 / 4194304)  # overwrite property_ROnce
-
-    def HG(self, a, b, maxit=_DIG53):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{HG
-           <https://web.Tecnico.ULisboa.PT/~mcasquilho/compute/com/,ellips/PerimeterOfEllipse.pdf>}
-           (HyperGeometric Gauss-Kummer) series.
-
-           @kwarg maxit: Number of iterations (C{int}), sufficient for C{B{b / a} > 0.125}.
-
-           @raise ValueError: No convergence for B{C{maxit}} iterations.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:
-            p  =  a + b
-            h  = (a - b) / p
-            ts = self._HGs(h, max(maxit, _DIG53))
-            p *= fsum(ts, nonfinites=True) * PI
-        return p
-
-    def _HGs(self, h, maxit):
-        '''(INTERNAL) Yield the C{HG} terms.
-        '''
-        t =  s_ = -1
-        s = _1_0
-        yield s
-        for u in range(-1, maxit * 2, 2):
-            t *= u / (u + 3) * h
-            t2 = t**2
-            s += t2
-            yield t2
-            if s == s_:
-                break
-            s_ = s
-        else:
-            s -= s_ - t2
-            raise self._Error(maxit, t2, s)
-
-#   def LS(self, a, b):
-#       '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{Linderholm-Segal
-#          <https://www.JohnDCook.com/blog/2021/03/24/perimeter-of-an-ellipse>} formula, aka C{3/2 norm}.
-#       '''
-#       _, p, a, b = self._pab4(a, b)
-#       if p is None:
-#           p = pow(a, _1_5) + pow(b, _1_5)
-#           p = pow(p * _0_5, _2_3rd) * PI2
-#       return p
-
-    def _pab4(self, a, b):
-        _r = a < b
-        if _r:
-            a, b = b, a
-        if a > b:
-            if b > (a * self._TOL53_53):
-                p = None
-            elif b < 0:
-                t =  callername()  # underOK=True
-                t = _DOT_(typename(self), t)
-                raise _ValueError(unstr(t, a, b))
-            else:  # "flat"
-                p = a * _4_0
-        else:  # circle
-            p = a * PI2
-        return _r, p, a, b
-
-    def R2(self, a, b):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using U{Ramanujan's
-           2nd<https://PaulBourke.net/geometry/ellipsecirc>} approximation, C{B{b / a} > 0.9}.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:
-            p  =  a + b
-            h  = (a - b) / p
-            h *= _3_0 * h
-            h /=  sqrt(_4_0 - h) + _10_0  # /= chokes PyChecker?
-            p *= (h + _1_0) * PI
-        return p
-
-if not _FOR_DOCS:  # PYCHOK force epydoc
-    Elliperim = Elliperim()  # singleton
-del _FOR_DOCS
-
-
 def angle2chord(rad, radius=R_M):
     '''Get the chord length of a (central) angle or I{angular} distance.
 
@@ -599,15 +368,6 @@ def _dS(fun_, radius, wrap, *lls, **adjust):
     return r * radius
 
 
-def elliperim(a, b):
-    '''Compute the perimeter of an ellipse with semi-axes C{a} and C{b}
-       using the C{Elliperim.e2k} or C{Elliperim.AGM} method.
-
-       @return: The perimeter (C{scalar}, same units as C{a} and C{b}).
-    '''
-    return Elliperim.e2k(a, b, Elliperim.E2k)
-
-
 def _ellipsoidal(earth, where):
     '''(INTERNAL) Helper for distances.
     '''
@@ -1167,7 +927,8 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
     n, kwds = _name2__(name_LatLon_and_kwds, name__=hartzell)
     try:
         D = _spherical_datum(earth, name__=hartzell)
-        r, h, i = _MODS.triaxials.triaxial5._hartzell3(pov, los, D.ellipsoid._triaxial)
+        m = _MODS._triaxials_triaxial5
+        r, h, i = m._hartzell3(pov, los, D.ellipsoid._triaxial)
 
         C = _MODS.cartesianBase.CartesianBase
         if kwds:

pygeodesy/fsums.py

@@ -52,9 +52,8 @@ from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DMAIN_, _DOT_, _from_, \
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
 from pygeodesy.named import _name__, _name2__, _Named, _NamedTuple, \
                             _NotImplemented,  _ALL_LAZY, _MODS
-from pygeodesy.props import _allPropertiesOf_n, deprecated_method, \
-                             deprecated_property_RO, Property, \
-                             Property_RO, property_RO
+from pygeodesy.props import _allPropertiesOf_n, deprecated_method, Property, \
+                             deprecated_property_RO, Property_RO, property_RO
 from pygeodesy.streprs import Fmt, fstr, unstr
 # from pygeodesy.units import Float, Int  # from .constants
 
@@ -62,7 +61,7 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '25.12.24'
+__version__ = '26.02.02'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -197,8 +196,7 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
     _2FACTOR = pow(2, (MANT_DIG + 1) // 2) + _1_0  # 134217729 if MANT_DIG == 53
 
     def _2split3(x):
-        # Split U{Algorithm 3.2
-        # <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
+        # Split U{Algorithm 3.2<https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>}
         a  = c = x * _2FACTOR
         a -= c - x
         b  = x - a
@@ -326,13 +324,31 @@ def nonfiniterrors(raiser=None):
          _xkwds_get1(d, _isfine=_isfinite) is _isfinite) if d else True
 
 
-def _1primed(xs):  # in .fmath
-    '''(INTERNAL) 1-Primed summation of iterable C{xs}
+# def _nsum(xs):
+#     '''(INTERNAL) U{Neumaier summation
+#        <https://StackOverflow.com/questions/78633770/can-neumaier-summation-be-sped-up>},
+#        see IV. Verbessertes Kahan-Babuška-Verfahren.
+#     '''
+#     s = r = _0_0
+#     for x in map(float, xs):
+#         t = s + x
+#         if fabs(x) <= fabs(s):
+#             r += (s - t) + x
+#         else:
+#             r += (x - t) + s
+#         s = t
+#     return s + r
+
+
+def _1primed(xs, *ys):  # in .fmath
+    '''(INTERNAL) 1-Primed summation of iterable C{xs} less any C{ys}
        items, all I{known} to be C{scalar}.
     '''
     yield _1_0
     for x in xs:
         yield x
+    for y in ys:
+        yield -y
     yield _N_1_0
 
 
@@ -485,10 +501,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
               i.e. any C{type} having method C{__float__}.
 
        @note: Handling of I{non-finites} as C{inf}, C{INF}, C{NINF}, C{nan} and C{NAN} is
-              determined by function L{nonfiniterrors<fsums.nonfiniterrors>} for the default
-              or by method L{nonfinites<Fsum.nonfinites>} for individual C{Fsum} instances,
-              overruling the default.  For backward compatibility, I{non-finites} raise
-              exceptions by default.
+              determined globally by function L{nonfiniterrors<fsums.nonfiniterrors>} or
+              by method L{nonfinites<Fsum.nonfinites>} for individual C{Fsum} instances,
+              overruling the global setting.  For backward compatibility, I{non-finites}
+              raise exceptions by default.
 
        @see: U{Hettinger<https://GitHub.com/ActiveState/code/tree/master/recipes/Python/
              393090_Binary_floating_point_summatiaccurate_full/recipe-393090.py>},
@@ -1333,11 +1349,10 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                     H._fadd(c, up=False)
             else:  # x == 0
                 H = cs[0] if n else 0
-            self._fadd(H)
+            return self._fadd(H)
         except Exception as X:
             t = unstr(where, x, *cs, _ELLIPSIS=4, incx=incx)
             raise self._ErrorX(X, _add_op_, t)
-        return self
 
     def _finite(self, other, op=None):
         '''(INTERNAL) Return B{C{other}} if C{finite}.
@@ -1449,6 +1464,12 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                               override L{nonfinites<Fsum.nonfinites>} and
                               the L{nonfiniterrors} default (C{bool}).
         '''
+        f = self._fma(other1, other2, **nonfinites)
+        return self._fset(f)
+
+    def _fma(self, other1, other2, **nonfinites):  # in .elliptic
+        '''(INTERNAL) Return C{self * B{other1} + B{other2}}.
+        '''
         op  = typename(self.fma)
         _fs = self._ps_other
         try:
@@ -1459,7 +1480,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             elif _residue(other1) or _residue(other2):
                 fs = _2split3s(_fs(op, other1))
                 fs = _2products(s, fs, *_fs(op, other2))
-                f  = _Psum(self._ps_acc([], fs, up=False), name=op)
+                f  =  Fsum(fs, name=op, **nonfinites)
             else:
                 f  = _fma(s, other1, other2)
                 f  = _2finite(f, **self._isfine)
@@ -1469,7 +1490,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             f  = self._mul_reduce(s, other1)  # INF, NAN, NINF
             f += sum(_fs(op, other2))
             f  = self._nonfiniteX(X, op, f, **nonfinites)
-        return self._fset(f)
+        return f
 
     def fma_(self, *xys, **nonfinites):
         '''Fused-multiply-accumulate C{for i in range(0, len(xys), B{2}):
@@ -2280,7 +2301,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         # assert isscalar(s) and isscalar(x)
         return self._pow_2_3(s, x, other, op, **raiser_RESIDUAL)
 
-    def _ps_acc(self, ps, xs, up=True, **unused):
+    def _ps_acc(self, ps, xs, up=True, **unused):  # in .geoids._Dotf and ._Hornerf
         '''(INTERNAL) Accumulate C{xs} known scalars into list C{ps}.
         '''
         n   =  0
@@ -2350,15 +2371,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _ps_1sum(self, *less):
         '''(INTERNAL) Return the partials sum, 1-primed C{less} some scalars.
         '''
-        def _1psls(ps, ls):
-            yield _1_0
-            for p in ps:
-                yield  p
-            for p in ls:
-                yield -p
-            yield _N_1_0
-
-        return _fsum(_1psls(self._ps, less))
+        return _fsum(_1primed(self._ps, *less))
 
     def _raiser(self, r, s, raiser=True, **RESIDUAL):
         '''(INTERNAL) Does ratio C{r / s} exceed the RESIDUAL threshold
@@ -2720,7 +2733,7 @@ try:
 except ImportError:
     _sum =  sum
 
-    def _fsum(xs):  # in .elliptic
+    def _fsum(xs):  # in .elliptic, .geoids
         '''(INTERNAL) Precision summation, Python 2.5-.
         '''
         F = Fsum(name=_fsum.name, f2product=False, nonfinites=True)
@@ -2861,8 +2874,11 @@ if __name__ == _DMAIN_:
         # copied from Hettinger, see L{Fsum} reference
         from pygeodesy import frandoms, printf
 
+#       printf(typename(_sum),  end=_COMMASPACE_)
         printf(typename(_fsum), end=_COMMASPACE_)
         printf(typename(_psum), end=_COMMASPACE_)
+        printf(len(Fsum.__dict__), end=_COMMASPACE_)
+#       printf(len(globals()), end=_COMMASPACE_)
 
         F = Fsum()
         if F.is_math_fsum():

pygeodesy/geod3solve.py

@@ -26,7 +26,7 @@ from pygeodesy.units import Degrees, Meter
 # from pygeodesy.utily import sincos2d  # from .karney
 
 __all__ = _ALL_LAZY.geod3solve
-__version__ = '25.12.31'
+__version__ = '26.01.04'
 
 _Triaxial3_WGS84 = Triaxial3s.WGS84_3r  # a=6378172, b=6378102, c=6356752
 
@@ -48,16 +48,31 @@ class Geod3Solve8Tuple(_GTuple):
     _Names_ = ('bet1', 'omg1', 'alp1', 'bet2', 'omg2', 'alp2', _s12_, _a12_)
     _Units_ = ( Deg,    Deg,    Deg,    Deg,    Deg,    Deg,    Meter, Deg)
 
+#   @Property_RO
+#   def A12(self):
+#       '''Approximate arc C{A12} as C{Deg}.
+#       '''
+#       t = self
+#       d = t.s12 or _0_0
+#       if d:
+#           a = hypot(Deg(t.bet2 - t.bet1).degrees,
+#                     Deg(t.omg2 - t.omg1).degrees)
+#           d = (-a) if d < 0 else a
+#       return Deg(d)
+
 
 class _Geodesic3SolveBase(_Solve3Base):
     '''(INTERNAL) Base class for L{Geodesic3Solve} and L{GeodesicLine3Solve}.
     '''
+    _a12x          =  Geod3Solve8Tuple._Names_.index(_a12_)  # last
     _Error         =  Geodesic3Error
     _Names_Direct  = _Names_Distance = \
-    _Names_Inverse =  Geod3Solve8Tuple._Names_[:7]  # 7 only, always
+    _Names_Inverse =  Geod3Solve8Tuple._Names_[:_a12x]  # 7 only, always
     _triaxial3     = _Triaxial3_WGS84
     _Xable_name    = _Xables.Geod3Solve.__name__  # typename
     _Xable_path    = _Xables.Geod3Solve()
+#   assert _a12x  ==  len(Geod3Solve8Tuple._Names_) - 1
+    del _a12x
 
     @Property_RO
     def a(self):
@@ -162,7 +177,7 @@ class Geodesic3Solve(_Geodesic3SolveBase):
         '''
         a = r.s12 or _0_0
         if a:
-            t = self.triaxial3
+            t =  self.triaxial3
             z = _toAzi(r.alp1) + _toAzi(r.alp2)
             s, c = sincos2d(z * _0_5)
             a *= hypot(_over(s, t.perimeter4ab),  # azimuth!