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

pygeodesy/fsums.py

@@ -48,12 +48,12 @@ from pygeodesy.errors import _AssertionError, _OverflowError, _TypeError, \
                              _ValueError, _xError, _xError2, _xkwds, \
                              _xkwds_get, _xkwds_get1, _xkwds_not, \
                              _xkwds_pop, _xsError
-from pygeodesy.internals import _enquote, _passarg
+from pygeodesy.internals import _enquote, _getPYGEODESY, _MODS, _passarg
 from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DOT_, _from_, \
                              _not_finite_, _SPACE_, _std_, _UNDER_
-from pygeodesy.lazily import _ALL_LAZY, _getenv, _sys_version_info2
+# from pygeodesy.lazily import _ALL_LAZY  # from .named
 from pygeodesy.named import _name__, _name2__, _Named, _NamedTuple, \
-                            _NotImplemented
+                            _NotImplemented,  _ALL_LAZY
 from pygeodesy.props import _allPropertiesOf_n, deprecated_method, \
                              deprecated_property_RO, Property, \
                              Property_RO, property_RO
@@ -64,7 +64,7 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '24.10.09'
+__version__ = '24.11.11'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -79,15 +79,15 @@ from pygeodesy.interns import (
 )
 _floordiv_op_ = _truediv_op_ * 2  # _DSLASH_
 _divmod_op_   = _floordiv_op_ + _mod_op_
-_F2PRODUCT    = _getenv('PYGEODESY_FSUM_F2PRODUCT', NN)
+_F2PRODUCT    = _getPYGEODESY('FSUM_F2PRODUCT')
 _iadd_op_     = _add_op_ + _fset_op_  # in .auxilats.auxAngle, .fstats
 _integer_     = 'integer'
 _isub_op_     = _sub_op_ + _fset_op_  # in .auxilats.auxAngle
 _NONFINITEr   = _0_0  # NOT INT0!
-_NONFINITES   = _getenv('PYGEODESY_FSUM_NONFINITES', NN)
+_NONFINITES   = _getPYGEODESY('FSUM_NONFINITES')
 _non_zero_    = 'non-zero'
 _pow_op_      = _mul_op_ * 2  # _DSTAR_
-_RESIDUAL_0_0 = _getenv('PYGEODESY_FSUM_RESIDUAL', _0_0)
+_RESIDUAL_0_0 = _getPYGEODESY('FSUM_RESIDUAL', _0_0)
 _significant_ = 'significant'
 _threshold_   = 'threshold'
 
@@ -163,9 +163,11 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
 
         _2n_d = None  # redef
 
-    def _fmaX(r, *a_b_c):  # like Python 3.13+ I{Modules/mathmodule.c}:
-        # raise a ValueError for a NAN result from non-NAN C{a_b_c}s or an
-        # OverflowError for a non-NAN non-finite from all finite C{a_b_c}s.
+    def _fmaX(r, *a_b_c):  # PYCHOK no cover
+        # handle non-finite as Python 3.13+ C-function U{math_fma_impl<https://
+        # GitHub.com/python/cpython/blob/main/Modules/mathmodule.c#L2305>}:
+        #  raise a ValueError for a NAN result from non-NAN C{a_b_c}s or an
+        #  OverflowError for a non-NAN non-finite from all finite C{a_b_c}s.
         if isnan(r):
             def _x(x):
                 return not isnan(x)
@@ -212,11 +214,11 @@ except  ImportError:  # PYCHOK DSPACE! Python 3.12-
         return map(_2split3, xs)
 
 
-def f2product(*two):
+def f2product(two=None):
     '''Turn accurate I{TwoProduct} multiplication on or off.
 
-       @arg two: If C{True}, turn I{TwoProduct} on, if C{False} off or
-                 if C{None} or omitted, keep the current setting.
+       @kwarg two: If C{True}, turn I{TwoProduct} on, if C{False} off or
+                   if C{None} or omitted, keep the current setting.
 
        @return: The previous setting (C{bool}).
 
@@ -226,8 +228,8 @@ def f2product(*two):
              equivalent, slower implementation when not available.
     '''
     t = Fsum._f2product
-    if two and two[0] is not None:
-        Fsum._f2product = bool(two[0])
+    if two is not None:
+        Fsum._f2product = bool(two)
     return t
 
 
@@ -318,14 +320,14 @@ def _NonfiniteError(x):
            _ValueError    if isnan(x) else _AssertionError)
 
 
-def nonfiniterrors(*raiser):
+def nonfiniterrors(raiser=None):
     '''Throw C{OverflowError} and C{ValueError} exceptions for or
        handle I{non-finite} C{float}s as C{inf}, C{INF}, C{NINF},
        C{nan} and C{NAN} in summations and multiplications.
 
-       @arg raiser: If C{True}, throw exceptions, if C{False} handle
-                    I{non-finites} or if C{None} or omitted, leave
-                    the setting unchanged.
+       @kwarg raiser: If C{True}, throw exceptions, if C{False} handle
+                      I{non-finites} or if C{None} or omitted, leave
+                      the setting unchanged.
 
        @return: Previous setting (C{bool}).
 
@@ -333,8 +335,8 @@ def nonfiniterrors(*raiser):
               C{nan} and C{NAN} a C{ValueError}.
     '''
     d = Fsum._isfine
-    if raiser and raiser[0] is not None:
-        Fsum._isfine = {} if bool(raiser[0]) else Fsum._nonfinites_isfine_kwds[True]
+    if raiser is not None:
+        Fsum._isfine = {} if bool(raiser) else Fsum._nonfinites_isfine_kwds[True]
     return (False if d is Fsum._nonfinites_isfine_kwds[True] else
          _xkwds_get1(d, _isfine=_isfinite) is _isfinite) if d else True
 
@@ -516,7 +518,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
        @see: Module L{fsums<pygeodesy.fsums>} for env variables C{PYGEODESY_FSUM_F2PRODUCT},
              C{PYGEODESY_FSUM_NONFINITES} and C{PYGEODESY_FSUM_RESIDUAL}.
     '''
-    _f2product = _sys_version_info2 > (3, 12) or bool(_F2PRODUCT)
+    _f2product = _MODS.sys_version_info2 > (3, 12) or bool(_F2PRODUCT)
     _isfine    = {}  # == _isfinite, see nonfiniterrors()
     _n         =  0
 #   _ps        = []  # partial sums
@@ -645,10 +647,6 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         f = self._copy_2(self.__floordiv__)
         return f._floordiv(other, _floordiv_op_)
 
-    def __format__(self, *other):  # PYCHOK no cover
-        '''Not implemented.'''
-        return _NotImplemented(self, *other)
-
     def __ge__(self, other):
         '''Return C{(B{self} >= B{other})}, see C{__eq__}.
         '''
@@ -913,6 +911,14 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         f = self._copy_2r(other, self.__rdivmod__)
         return f._fdivmod2(self, _divmod_op_)
 
+#       turned off, called by _deepcopy and _copy
+#   def __reduce__(self):  # Python 3.8+
+#       ''' Pickle, like std C{fractions.Fraction}, see U{__reduce__
+#           <https://docs.Python.org/3/library/pickle.html#object.__reduce__>}
+#       '''
+#       dict_ = self._Fsum_as().__dict__  # no __setstate__
+#       return (self.__class__, self.partials, dict_)
+
 #   def __repr__(self):
 #       '''Return the default C{repr(this)}.
 #       '''
@@ -926,7 +932,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         f = self._copy_2r(other, self.__rfloordiv__)
         return f._floordiv(self, _floordiv_op_)
 
-    def __rmatmul__(self, other):  # PYCHOK no cover
+    def __rmatmul__(self, other):  # PYCHOK no coveS
         '''Not implemented.'''
         return _NotImplemented(self, other)
 
@@ -1015,7 +1021,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
 
     __trunc__ = __int__
 
-    if _sys_version_info2 < (3, 0):  # PYCHOK no cover
+    if _MODS.sys_version_info2 < (3, 0):  # PYCHOK no cover
         # <https://docs.Python.org/2/library/operator.html#mapping-operators-to-functions>
         __div__     = __truediv__
         __idiv__    = __itruediv__
@@ -1101,7 +1107,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     def _copy_2(self, which, name=NN):
         '''(INTERNAL) Copy for I{dyadic} operators.
         '''
-        n =  name or which.__name__  # _dunder_nameof
+        n =  name or which.__name__  # _DUNDER_nameof
         # NOT .classof due to .Fdot(a, *b) args, etc.
         f = _Named.copy(self, deep=False, name=n)
         f._ps = list(self._ps)  # separate list
@@ -1152,6 +1158,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             fs    = _xs(xs, **kwds)  # PYCHOK yield
             ps    =  self._ps
             ps[:] =  self._ps_acc(list(ps), fs, up=up)
+#           if len(ps) > 16:
+#               _ = _psum(ps, **self._isfine)
         return self
 
     def _facc_args(self, xs, **up):
@@ -1161,6 +1169,14 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         return self._fadd(xs[0], **up) if len(xs) == 1 else \
                self._facc(xs, **up)  # origin=1?
 
+    def _facc_dot(self, n, xs, ys, **kwds):  # in .fmath
+        '''(INTERNAL) Accumulate C{fdot(B{xs}, *B{ys})}.
+        '''
+        if n > 0:
+            _f = Fsum(**kwds)
+            self._facc(_f(x).fmul(y) for x, y in zip(xs, ys))  # PYCHOK attr?
+        return self
+
     def _facc_neg(self, xs, **up_origin):
         '''(INTERNAL) Accumulate more C{xs}, negated.
         '''
@@ -1452,7 +1468,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
         try:
             s, r = self._fprs2
             if r:
-                f  =  self._f2mul(self.fma, other1, **nonfinites)
+                f  =  self._f2mul(self.fma, (other1,), **nonfinites)
                 f +=  other2
             elif _residue(other1) or _residue(other2):
                 fs = _2split3s(_fs(op, other1))
@@ -1491,36 +1507,41 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     @deprecated_method
     def f2mul(self, *others, **raiser):
         '''DEPRECATED on 2024.09.13, use method L{f2mul_<Fsum.f2mul_>}.'''
-        return self._fset(self.f2mul_(*others, **raiser))
+        return self._fset(self.f2mul_(others, **raiser))
 
-    def f2mul_(self, *others, **nonfinites):  # in .fmath.f2mul
+    def f2mul_(self, *others, **f2product_nonfinites):  # in .fmath.f2mul
         '''Return C{B{self} * B{other} * B{other} ...} for all B{C{others}} using cascaded,
-           accurate multiplication like with L{f2product<Fsum.f2product>} set to C{True}.
+           accurate multiplication like with L{f2product<Fsum.f2product>}C{(B{True})}.
 
            @arg others: Multipliers (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}), all
                         positional.
-           @kwarg nonfinites: Use C{B{nonfinites}=True} or C{False}, to override both
-                              L{nonfinites<Fsum.nonfinites>} and the L{nonfiniterrors}
-                              default (C{bool}).
+           @kwarg f2product_nonfinites: Use C{B{f2product=False}} to override the default
+                            C{True} and C{B{nonfinites}=True} or C{False}, to override
+                            settings L{nonfinites<Fsum.nonfinites>} and L{nonfiniterrors}.
 
            @return: The cascaded I{TwoProduct} (L{Fsum} or C{float}).
 
            @see: U{Equations 2.3<https://www.TUHH.De/ti3/paper/rump/OzOgRuOi06.pdf>}
         '''
-        return self._f2mul(self.f2mul_, *others, **nonfinites)
+        return self._f2mul(self.f2mul_, others, **f2product_nonfinites)
 
-    def _f2mul(self, where, *others, **nonfinites_raiser):
+    def _f2mul(self, where, others, f2product=True, **nonfinites_raiser):
         '''(INTERNAL) See methods C{fma} and C{f2mul_}.
         '''
-        f  = self._copy_2(where)
-        ps = f._ps
-        if ps and others:
-            op = where.__name__
-            try:
+        f = _Psum(self._ps, f2product=f2product, name=where.__name__)
+        if others and f:
+            if f.f2product():
+                def _pfs(f, ps):
+                    return _2products(f, _2split3s(ps))
+            else:
+                def _pfs(f, ps):  # PYCHOK redef
+                    return (f * p for p in ps)
+
+            op, ps = where.__name__, f._ps
+            try:  # as if self.f2product(True)
                 for other in others:  # to pinpoint errors
                     for p in self._ps_other(op, other):
-                        pfs   = _2products(p, _2split3s(ps))
-                        ps[:] =  f._ps_acc([], pfs, up=False)
+                        ps[:] = f._ps_acc([], _pfs(p, ps), update=False)
                 f._update()
             except TypeError as X:
                 raise self._ErrorX(X, op, other)
@@ -2299,11 +2320,11 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                     return (p * f for f in fs)
 
             for p in ps:
-                for f in _pfs(p, fs):
-                    yield f if _isfine(f) else _nfError(f)
+                for x in _pfs(p, fs):
+                    yield x if _isfine(x) else _nfError(x)
 
-        fs = _psfs(self._ps, factors, **self._isfine)
-        f  = _Psum(self._ps_acc([], fs, up=False), name=op)
+        xs = _psfs(self._ps, factors, **self._isfine)
+        f  = _Psum(self._ps_acc([], xs, up=False), name=op)
         return f
 
     @property_RO
@@ -2774,7 +2795,7 @@ def _xs(xs, _X=_X_ps, _x=float, _isfine=_isfinite,  # defaults for Fsum._facc
     i, x = 0, xs
     try:
         for i, x in enumerate(_xiterable(xs)):
-            if isinstance(x, _Fsum_2Tuple_types):
+            if _isFsum_2Tuple(x):
                 for p in _X(x):
                     yield p if _isfine(p) else _nfError(p)
             else:
@@ -2803,7 +2824,7 @@ def _xsum(which, xs, nonfinites=None, primed=0, **floats):  # origin=0
 # delete all decorators, etc.
 del _allPropertiesOf_n, deprecated_method, deprecated_property_RO, \
      Property, Property_RO, property_RO, _ALL_LAZY, _F2PRODUCT, \
-     MANT_DIG, _NONFINITES, _RESIDUAL_0_0, _getenv, _std_
+     MANT_DIG, _NONFINITES, _RESIDUAL_0_0, _getPYGEODESY, _std_
 
 if __name__ == '__main__':
 

pygeodesy/geodesici.py

@@ -38,11 +38,10 @@ from pygeodesy.errors import GeodesicError, IntersectionError, _an, \
 # from pygeodesy.errors import exception_chaining  # _MODS
 from pygeodesy.fmath import euclid, fdot
 from pygeodesy.fsums import Fsum, fsum1_,  _ceil
-from pygeodesy.interns import NN, _A_, _B_, _c_, _COMMASPACE_, \
-                             _HASH_, _M_, _not_, _SPACE_, _too_
-from pygeodesy.karney import Caps, _diff182, GDict, _sincos2de
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, \
-                             _getenv, _PYGEODESY_INTERSECTTOOL_
+from pygeodesy.interns import NN, _A_, _B_, _c_, _COMMASPACE_, _HASH_, \
+                             _M_, _not_, _SPACE_, _too_
+from pygeodesy.karney import Caps, _diff182, GDict, _sincos2de, _Xables
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import ADict, _NamedBase, _NamedTuple, _Pass
 # from pygeodesy.namedTuples import _LL4Tuple  # _MODS
 from pygeodesy.props import deprecated_method, Property, \
@@ -57,7 +56,7 @@ from pygeodesy.utily import sincos2,  atan2, fabs, radians
 # from math import atan2, ceil as _ceil, fabs, radians  # .fsums, .utily
 
 __all__ = _ALL_LAZY.geodesici
-__version__ = '24.08.28'
+__version__ = '24.10.22'
 
 _0t     =  0,  # int
 _1_1t   = -1, +1
@@ -470,8 +469,8 @@ class Intersectool(_IntersectBase, _SolveCapsBase):
     _Names_ABs   = _latA_, _lonA_, 'latB', 'lonB', _sAB_  # -C to stderr
     _Names_XDict = 'sA', 'sB', _c_  # plus 'k' from -i or 'sX0' from -R
     _o_alt       = _o__,  # Offset latA lonA aziA  latB lonB aziB  x0 y0
-    _Xable_name  = 'IntersectTool'
-    _Xable_path  = _getenv(_PYGEODESY_INTERSECTTOOL_, _PYGEODESY_INTERSECTTOOL_)
+    _Xable_name  = _Xables.IntersectTool.__name__
+    _Xable_path  = _Xables.IntersectTool()
 
     def __init__(self, a_geodesic=None, f=None, **name):
         '''New L{IntersectTool}.
@@ -1547,7 +1546,7 @@ if __name__ == '__main__':  # MCCABE 14
             ll4 += ll4.replace(_A_, _B_)
             llz  = _SPACE_(NN, _latA_, _lonA_, 'aziA')
             llz2 =  llz + llz.replace(_A_, _B_)
-            return dict(opts='-Verbose|V--version|v--help|h--Tool|T--Check|C-R meter-',
+            return dict(opts='-Verbose|V--version|v--help|h--Tool|T--Check|C-R <meter>-',
                         alts=((_c_ + llz2),
                               (_i_ + ll4),
                               (_m_ + ll4),
@@ -1587,8 +1586,8 @@ if __name__ == '__main__':  # MCCABE 14
                 I = Intersectool()  # PYCHOK I
                 if _V:
                     I.verbose = True
-                if I.IntersectTool in (_PYGEODESY_INTERSECTTOOL_, None):  # not set
-                    I.IntersectTool = '/opt/local/bin/IntersectTool'  # '/opt/local/Cellar/geographiclib/2.3/bin/IntersectTool'  # HomeBrew
+                if not _Xables.X_OK(I.IntersectTool):
+                    I.IntersectTool = _Xables.IntersectTool(_Xables.bin_)
                 elif _V:
                     _ = I.version
                 M, _T = None, True
@@ -1640,38 +1639,42 @@ if __name__ == '__main__':  # MCCABE 14
                 for i, X in enumerate(X):
                     printf(_COLONSPACE_(Fmt.INDEX(m, i), repr(X)))
 
+    def _examples():
+
+        from pygeodesy.internals import _usage_argv
+
+        s = _SPACE_(*_usage_argv(__file__))
+        for t in ('-h', '-h -n',
+                  '-c 0 0 45  40 10 135',
+                  '-C -c 0 0 45  40 10 135',
+                  '-T -R 2.6e7 -c 0 0 45  40 10 135',
+                  '-c 50 -4 -147.7  0 0 90',
+                  '-C -c 50 -4 -147.7  0 0 90',
+                  '# % echo 0 0  10 10  50 -4  50S 4W | IntersectTool -i  -p 0  -C',
+                  '# -631414 5988887 0 -3',
+                  '# -4.05187 -4.00000 -4.05187 -4.00000 0',
+                  '-m 0 0  10 10  50 -4  50S 4W',
+                  '-C -m 0 0  10 10  50 -4  50S 4W',
+                  '-i 0 0  10 10  50 -4  50S 4W',
+                  '-T -i 0 0  10 10  50 -4  50S 4W',
+                  '-C -i 0 0  10 10  50 -4  50S 4W',
+                  '-T -C -i 0 0  10 10  50 -4  50S 4W',
+                  '-V -T -i 0 0  10 10  50 -4  -50 -4',
+                  '-C -R 4e7 -c 50 -4 -147.7  0 0 90',
+                  '-T -C -R 4e7 -c 50 -4 -147.7  0 0 90',
+                  '-R 4e7 -i 0 0  10 10  50 -4  -50 -4',
+                  '-T -R 4e7 -i 0 0  10 10  50 -4  -50 -4'):
+            if t.startswith(_HASH_):
+                printf(t, nl=int(t[2] == '%'))
+            else:
+                printf(_SPACE_(_HASH_, s, t), nl=1)
+                argv[1:] = t = t.split()
+                _main(t)
+
     from sys import argv, stderr
     try:
         if len(argv) == 2 and argv[1] == __help_:
-            from pygeodesy.internals import _usage_argv
-
-            s = _SPACE_(*_usage_argv(__file__))
-            for t in ('-h', '-h -n',
-                      '-c 0 0 45  40 10 135',
-                      '-C -c 0 0 45  40 10 135',
-                      '-T -R 2.6e7 -c 0 0 45  40 10 135',
-                      '-c 50 -4 -147.7  0 0 90',
-                      '-C -c 50 -4 -147.7  0 0 90',
-                      '# % echo 0 0  10 10  50 -4  50S 4W | IntersectTool -i  -p 0  -C',
-                      '# -631414 5988887 0 -3',
-                      '# -4.05187 -4.00000 -4.05187 -4.00000 0',
-                      '-m 0 0  10 10  50 -4  50S 4W',
-                      '-C -m 0 0  10 10  50 -4  50S 4W',
-                      '-i 0 0  10 10  50 -4  50S 4W',
-                      '-T -i 0 0  10 10  50 -4  50S 4W',
-                      '-C -i 0 0  10 10  50 -4  50S 4W',
-                      '-T -C -i 0 0  10 10  50 -4  50S 4W',
-                      '-V -T -i 0 0  10 10  50 -4  -50 -4',
-                      '-C -R 4e7 -c 50 -4 -147.7  0 0 90',
-                      '-T -C -R 4e7 -c 50 -4 -147.7  0 0 90',
-                      '-R 4e7 -i 0 0  10 10  50 -4  -50 -4',
-                      '-T -R 4e7 -i 0 0  10 10  50 -4  -50 -4'):
-                if t.startswith(_HASH_):
-                    printf(t, nl=int(t[2] == '%'))
-                else:
-                    printf(_SPACE_(_HASH_, s, t), nl=1)
-                    argv[1:] = t = t.split()
-                    _main(t)
+            _examples()
         else:
             _main(argv[1:])
 

pygeodesy/geodesicw.py

@@ -21,7 +21,7 @@ from pygeodesy.datums import _earth_datum, _WGS84,  _EWGS84
 from pygeodesy.errors import _AssertionError, GeodesicError, \
                               IntersectionError
 from pygeodesy.fsums import Fsum,  Fmt, unstr
-from pygeodesy.internals import _dunder_nameof, _under
+from pygeodesy.internals import _DUNDER_nameof, _under
 from pygeodesy.interns import NN, _DOT_, _SPACE_, _to_, _too_
 from pygeodesy.karney import _atan2d, Caps, Direct9Tuple, GDict, \
                               Inverse10Tuple, _kWrapped
@@ -39,7 +39,7 @@ from contextlib import contextmanager
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.geodesicw
-__version__ = '24.07.12'
+__version__ = '24.11.02'
 
 _plumb_ = 'plumb'
 _TRIPS  =  65
@@ -94,14 +94,14 @@ class _gWrapped(_kWrapped):
                 if name:
                     self._name, _ = _name2__(name, _or_nameof=E)
 
-            def ArcDirect(self, lat1, lon1, azi1, a12, outmask=Caps._STD):
+            def ArcDirect(self, lat1, lon1, azi1, a12, outmask=Caps._STD):  # PYCHOK no cover
                 '''Return the C{_Geodesic.ArcDirect} result as L{GDict}.
                 '''
                 with _wargs(self, lat1, lon1, azi1, a12, outmask) as args:
                     d = _Geodesic.ArcDirect(self, *args)
                 return GDict(d)
 
-            def ArcDirectLine(self, lat1, lon1, azi1, a12, caps=Caps._STD_LINE, **name):
+            def ArcDirectLine(self, lat1, lon1, azi1, a12, caps=Caps._STD_LINE, **name):  # PYCHOK no cover
                 '''Return the C{_Geodesic.ArcDirectLine} as I{wrapped} C{GeodesicLine}.
                 '''
                 return self._GenDirectLine(lat1, lon1, azi1, True, a12, caps, **name)
@@ -445,7 +445,7 @@ _wrapped = _gWrapped()  # PYCHOK singleton, .ellipsoids, .test/base.py
 
 class Geodesic(_gWrapped):  # overwritten by 1st instance
     '''I{Wrapper} around I{Karney}'s class U{geographiclib.geodesic.Geodesic
-       <https://geographiclib.sourceforge.io/Python/doc/code.html>}.
+       <https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
     '''
     def __new__(unused, a_ellipsoid=_EWGS84, f=None, **name):
         '''Return a I{wrapped} C{geodesic.Geodesic} instance from I{Karney}'s
@@ -465,7 +465,7 @@ class Geodesic(_gWrapped):  # overwritten by 1st instance
 
 class GeodesicLine(_gWrapped):  # overwritten by 1st instance
     '''I{Wrapper} around I{Karney}'s class U{geographiclib.geodesicline.GeodesicLine
-       <https://geographiclib.sourceforge.io/Python/doc/code.html>}.
+       <https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
     '''
     def __new__(unused, geodesic, lat1, lon1, azi1, caps=Caps._STD_LINE, **name):
         '''Return a I{wrapped} C{geodesicline.GeodesicLine} instance from I{Karney}'s
@@ -516,16 +516,15 @@ def _Intersecant2(gl, lat0, lon0, radius, tol=_TOL, form=F_D):  # MCCABE in LatL
     # (INTERNAL) Return the intersections of a circle at C{lat0, lon0}
     # and a geodesic line as a 2-Tuple C{(P, Q)}, each a C{GDict}.
     r  =  Radius_(radius)
-    n  = _dunder_nameof(_Intersecant2)[1:]
+    n  = _DUNDER_nameof(_Intersecant2)[1:]
     _P =  gl.Position
     _I =  gl.geodesic.Inverse
-    _a =  fabs
 
     def _R3(s):
         # radius, intersection, etc. at distance C{s}
         P = _P(s)
         d = _I(lat0, lon0, P.lat2, P.lon2)
-        return _a(d.s12), P, d
+        return fabs(d.s12), P, d
 
     def _bisect2(s, c, Rc, r, tol, _R3):
         _s = Fsum(c).fsumf_
@@ -536,18 +535,20 @@ def _Intersecant2(gl, lat0, lon0, radius, tol=_TOL, form=F_D):  # MCCABE in LatL
                 break
         else:  # b >>> s and c >>> s
             raise ValueError(Fmt.no_convergence(b, s))
-        __2 = _0_5  # Rb > r > Rc
+        # Rb > r > Rc
         for i in range(_TRIPS):  # 47-48
-            s = (b + c) * __2
+            s = (b + c) * _0_5
             R, P, d = _R3(s)
             if Rb > R > r:
                 b, Rb = s, R
             elif Rc < R < r:
                 c, Rc = s, R
-            t = _a(b - c)
-            if t < tol:  # or _a(R - r) < tol:
+#           else:
+#               break
+            t = fabs(b - c)
+            if t < tol:  # or fabs(R - r) < tol:
                 break
-        else:  # t = min(t, _a(R - r))
+        else:  # t = min(t, fabs(R - r))
             raise ValueError(Fmt.no_convergence(t, tol))
         i += C.iteration  # combine iterations
         P.set_(lat0=lat0, lon0=lon0, azi0=d.azi1, iteration=i,
@@ -558,13 +559,13 @@ def _Intersecant2(gl, lat0, lon0, radius, tol=_TOL, form=F_D):  # MCCABE in LatL
     # one the plumb, pseudo-rhumb line to the other
     C = _PlumbTo(gl, lat0, lon0, tol=tol)
     try:
-        a = _a(C.s02)  # distance between centers
+        a = fabs(C.s02)  # distance between centers
         if a < r:
             c =  C.s12  # distance along pseudo-rhumb line
             h = _copysign(r, c)  # past half chord length
             P, p = _bisect2( h, c, a, r, tol, _R3)
             Q, q = _bisect2(-h, c, a, r, tol, _R3)
-            if _a(p - q) < max(EPS, tol):
+            if fabs(p - q) < max(EPS, tol):
                 Q = P
         elif a > r:
             raise ValueError(_too_(Fmt.distant(a)))

pygeodesy/geodesicx/__init__.py

@@ -4,7 +4,7 @@
 u'''A pure Python version of I{Karney}'s C++ classes U{GeodesicExact
 <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicExact.html>}
 and U{GeodesicLineExact
-<https://geographiclib.sourceforge.io/C++/doc/classGeographicLib_1_1GeodesicLine.html>}.
+<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicLine.html>}.
 
 For more details, see the C++ U{GeographicLib<https://GeographicLib.SourceForge.io/C++/doc/index.html>}
 documentation, especially the U{Class List<https://GeographicLib.SourceForge.io/C++/doc/annotated.html>}
@@ -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.09.06'
+__version__ = '24.11.02'
 
 # **) MIT License
 #

pygeodesy/geodesicx/gxarea.py

@@ -19,10 +19,11 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import isodd, unsigned0
 from pygeodesy.constants import NAN, _0_0, _0_5, _720_0
+from pygeodesy.internals import printf
 # from pygeodesy.interns import _COMMASPACE_  # from .lazily
 from pygeodesy.karney import Area3Tuple, _diff182, GeodesicError, \
                             _norm180, _remainder, _sum3
-from pygeodesy.lazily import _ALL_DOCS, printf,  _COMMASPACE_
+from pygeodesy.lazily import _ALL_DOCS,  _COMMASPACE_
 from pygeodesy.named import ADict, callername, _NamedBase,  pairs
 from pygeodesy.props import Property, Property_RO, property_RO
 # from pygeodesy.streprs import pairs  # from .named
@@ -30,7 +31,7 @@ from pygeodesy.props import Property, Property_RO, property_RO
 from math import fmod as _fmod
 
 __all__ = ()
-__version__ = '24.09.04'
+__version__ = '24.10.14'
 
 
 class GeodesicAreaExact(_NamedBase):