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

pygeodesy/fmath.py

@@ -12,9 +12,8 @@ from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
                                _0_0, _0_125, _1_6th, _0_25, _1_3rd, _0_5, _1_0, \
                                _1_5, _copysign_0_0, isfinite, remainder
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
-                             _xError, _xkwds_pop2, _xsError
-from pygeodesy.fsums import _2float, Fsum, fsum, _isFsum_2Tuple, _1primed, \
-                             Fmt, unstr
+                             _xError, _xkwds, _xkwds_pop2, _xsError
+from pygeodesy.fsums import _2float, Fsum, fsum, _isFsum_2Tuple,  Fmt, unstr
 from pygeodesy.interns import MISSING, _negative_, _not_scalar_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
@@ -24,7 +23,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '24.10.11'
+__version__ = '24.11.08'
 
 # sqrt(2) - 1 <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ... ~ 3730904090310553 / 9007199254740992
@@ -62,14 +61,7 @@ class Fdot(Fsum):
         n = len(b)
         if len(a) != n:  # PYCHOK no cover
             raise LenError(Fdot, a=len(a), b=n)
-        self._faddot(n, a, b, **kwds)
-
-    def _faddot(self, n, xs, ys, **kwds):
-        if n > 0:
-            _f = Fsum(**kwds)
-            r = (_f(x).fmul(y) for x, y in zip(xs, ys))  # PYCHOK attr?
-            self.fadd(_1primed(r) if n < 4 else r)  # PYCHOK attr?
-        return self
+        self._facc_dot(n, a, b, **kwds)
 
 
 class Fhorner(Fsum):
@@ -129,7 +121,7 @@ class Fhypot(Fsum):
             raise self._ErrorXs(X, xs, root=r)
 
 
-class Fpolynomial(Fdot):
+class Fpolynomial(Fsum):
     '''Precision polynomial evaluation.
     '''
     def __init__(self, x, *cs, **name_f2product_nonfinites_RESIDUAL):
@@ -150,12 +142,10 @@ class Fpolynomial(Fdot):
 
            @see: Class L{Fhorner}, function L{fpolynomial} and method L{Fsum.fadd}.
         '''
-        Fsum.__init__(self, *cs[:1], **name_f2product_nonfinites_RESIDUAL)
+        Fsum.__init__(self, **name_f2product_nonfinites_RESIDUAL)
         n = len(cs) - 1
-        if n > 0:
-            self._faddot(n, cs[1:], _powers(x, n), **name_f2product_nonfinites_RESIDUAL)
-        elif n < 0:
-            self(_0_0)
+        self(_0_0 if n < 0 else cs[0])
+        self._facc_dot(n, cs[1:], _powers(x, n), **name_f2product_nonfinites_RESIDUAL)
 
 
 class Fpowers(Fsum):
@@ -431,35 +421,48 @@ def favg(a, b, f=_0_5, nonfinites=True):
     return float(F)
 
 
-def fdot(a, *b, **start):
-    '''Return the precision dot product M{sum(a[i] * b[i] for ni=0..len(a))}.
+def fdot(xs, *ys, **start_f2product_nonfinites):
+    '''Return the precision dot product M{sum(xs[i] * ys[i] for i in range(len(xs)))}.
 
-       @arg a: Iterable of values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
-       @arg b: Other values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}), all
+       @arg xs: Iterable of values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
+       @arg ys: Other values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}), all
                positional.
-       @kwarg start: Optional bias C{B{start}=0} (C{scalar}, an L{Fsum} or
-                     L{Fsum2Tuple}).
+       @kwarg start_f2product_nonfinites: Optional bias C{B{start}=0} (C{scalar}, an
+                    L{Fsum} or L{Fsum2Tuple}) and settings C{B{f2product}=None} (C{bool})
+                    and C{B{nonfinites=True}} (C{bool}), see class L{Fsum<Fsum.__init__>}.
 
        @return: Dot product (C{float}).
 
-       @raise LenError: Unequal C{len(B{a})} and C{len(B{b})}.
+       @raise LenError: Unequal C{len(B{xs})} and C{len(B{ys})}.
 
        @see: Class L{Fdot}, U{Algorithm 5.10 B{DotK}
              <https://www.TUHH.De/ti3/paper/rump/OgRuOi05.pdf>} and function
              C{math.sumprod} in Python 3.12 and later.
     '''
-    D = Fdot(a, nonfinites=True, *b, **start)
+    D = Fdot(xs, *ys, **_xkwds(start_f2product_nonfinites, nonfinites=True))
     return float(D)
 
 
-def fdot3(xs, ys, zs, start=0):
-    '''Return the precision dot product M{start + sum(a[i] * b[i] * c[i]
-       for i=0..len(a)-1)}.
+def fdot_(*xys, **start_f2product_nonfinites):
+    '''Return the (precision) dot product M{sum(xys[i] * xys[i+1] for i in range(0, len(xys), B{2}))}.
+
+       @arg xys: Pairwise values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}), all positional.
+
+       @see: Function L{fdot} for further details.
+
+       @return: Dot product (C{float}).
+    '''
+    return fdot(xys[0::2], *xys[1::2], **start_f2product_nonfinites)
+
+
+def fdot3(xs, ys, zs, **start_f2product_nonfinites):
+    '''Return the (precision) dot product M{start + sum(xs[i] * ys[i] * zs[i] for i in range(len(xs)))}.
 
        @arg xs: Iterable (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
        @arg ys: Iterable (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
        @arg zs: Iterable (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
-       @kwarg start: Optional bias (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
+
+       @see: Function L{fdot} for further details.
 
        @return: Dot product (C{float}).
 
@@ -469,17 +472,16 @@ def fdot3(xs, ys, zs, start=0):
     if not n == len(ys) == len(zs):
         raise LenError(fdot3, xs=n, ys=len(ys), zs=len(zs))
 
-    D  = Fdot((), nonfinites=True, start=start)
-    _f = Fsum(nonfinites=True)  # f2product=True
-    r  = (_f(x).f2mul_(y, z) for x, y, z in zip(xs, ys, zs))
-    D  = D.fadd(_1primed(r) if n < 4 else r)
+    D  = Fdot((), **_xkwds(start_f2product_nonfinites, nonfinites=True))
+    kwds = dict(f2product=D.f2product(), nonfinites=D.nonfinites())
+    _f = Fsum(**kwds)
+    D  = D._facc(_f(x).f2mul_(y, z, **kwds) for x, y, z in zip(xs, ys, zs))
     return float(D)
 
 
 def fhorner(x, *cs, **incx):
-    '''Horner form evaluation of polynomial M{sum(cs[i] * x**i for
-       i=0..n)} with in- or decreasing exponent M{sum(... i=n..0)},
-       where C{n = len(cs) - 1}.
+    '''Horner form evaluation of polynomial M{sum(cs[i] * x**i for i=0..n)} as
+       in- or decreasing exponent M{sum(... i=n..0)}, where C{n = len(cs) - 1}.
 
        @return: Horner sum (C{float}).
 

pygeodesy/formy.py

@@ -1156,7 +1156,7 @@ class _idllmn6(object):  # see also .geodesicw._wargs, .latlonBase._toCartesian3
                         m = _MODS.ellipsoidalKarney
                     except ImportError:
                         m = _MODS.ellipsoidalExact
-                    _i = m._intersections2 if s else m._intersection3  # ellispoidalBaseDI
+                    _i = m._intersections2 if s else m._intersection3  # ellipsoidalBaseDI
                 else:
                     raise _TypeError(datum=datum)
             yield _i, d, lat2, lon2, m, n
@@ -1231,7 +1231,8 @@ def intersection2(lat1, lon1, bearing1,
 
         else:
             t = _i(m.LatLon(lat1, lon1, datum=d), b1,
-                   m.LatLon(lat2, lon2, datum=d), b2, height=0, wrap=False)
+                   m.LatLon(lat2, lon2, datum=d), b2,
+                     LatLon=None, height=0, wrap=False)
             if isinstance(t, Intersection3Tuple):  # ellipsoidal
                 t, _, _ = t
             t = LatLon2Tuple(t.lat, t.lon, name=n)

pygeodesy/fsums.py

@@ -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.22'
+__version__ = '24.11.11'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -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
 
@@ -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__}.
         '''
@@ -1171,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.
         '''
@@ -1462,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))
@@ -1501,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)
@@ -2309,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
@@ -2784,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:

pygeodesy/geodesicw.py

@@ -39,7 +39,7 @@ from contextlib import contextmanager
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.geodesicw
-__version__ = '24.10.14'
+__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
@@ -519,13 +519,12 @@ def _Intersecant2(gl, lat0, lon0, radius, tol=_TOL, form=F_D):  # MCCABE in LatL
     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/geodsolve.py

@@ -23,7 +23,7 @@ from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.10.14'
+__version__ = '24.11.02'
 
 
 class _GeodesicSolveBase(_SolveGDictBase):
@@ -181,15 +181,6 @@ class GeodesicSolve(_GeodesicSolveBase):
             ll2 = _unrollon(ll1, _Wrap.point(ll2))
         return self.InverseLine(ll1.lat, ll1.lon, ll2.lat, ll2.lon, **caps_name)
 
-#   def _InverseLine2(self, lat1, lon1, lat2, lon2, **caps_name):  # in .geodesici
-#       '''(INTERNAL) Helper for L{InverseLine} and L{_InverseLine}.
-#       '''
-#       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, r
-
     def InverseLine(self, lat1, lon1, lat2, lon2, **caps_name):  # PYCHOK no cover
         '''Set up a L{GeodesicLineSolve} to compute several points
            on a single geodesic.
@@ -270,14 +261,14 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase):
         '''
         return self._a13
 
-    def Arc(self):
+    def Arc(self):  # PYCHOK no cover
         '''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
+    def ArcPosition(self, a12, outmask=Caps.STANDARD):  # PYCHOK no cover
         '''Find the position on the line given B{C{a12}}.
 
            @arg a12: Spherical arc length from the first point to the
@@ -347,7 +338,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase):
         '''
         return self._s13
 
-    def SetArc(self, a13):
+    def SetArc(self, a13):  # PYCHOK no cover
         '''Set reference point 3 in terms relative to the first point.
 
            @arg a13: Spherical arc length from the first to the reference
@@ -362,13 +353,13 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase):
 #           _update_all(self)
         return self._s13
 
-    def SetDistance(self, s13):
+    def SetDistance(self, s13):  # PYCHOK no cover
         '''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}.
+           @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

pygeodesy/geoids.py

@@ -15,7 +15,7 @@ The L{GeoidG2012B} and L{GeoidPGM} interpolators both depend on U{scipy
 require those packages to be installed.
 
 In addition, each geoid interpolator needs C{grid knots} (down)loaded from
-a C{geoid} model file, I{specific to the interpolator}, more details below
+a C{geoid} model file, I{specific to the interpolator}.  More details below
 and in the documentation of the interpolator class.  For each interpolator,
 there are several interpolation choices, like I{linear}, I{cubic}, etc.
 
@@ -42,7 +42,7 @@ C{>>> h = ginterpolator(ll)}
 
 or
 
-C{>>> h0, h1, h2, ... = ginterpolator(ll0, ll1, ll2, ...)}
+C{>>> h1, h2, h3, ... = ginterpolator(ll1, ll2, ll3, ...)}
 
 or a list, tuple, generator, etc. of C{LatLon}s
 
@@ -118,7 +118,7 @@ except ImportError:  # Python 3+
     from io import BytesIO as _BytesIO  # PYCHOK expected
 
 __all__ = _ALL_LAZY.geoids
-__version__ = '24.10.11'
+__version__ = '24.11.05'
 
 _assert_         = 'assert'
 _bHASH_          = b'#'
@@ -159,7 +159,7 @@ class _GeoidBase(_HeightBase):
     _smooth   =  0      # used only for RectBivariateSpline
     _stdev    =  None   # fixed in GeoidKarney
     _u2B      =  0      # np.itemsize or undefined
-    _yx_hits  =  None   # cache hits, ala Karney
+    _yx_hits  =  None   # cache hits, ala Karney's
 
 #   _lat_d  = _0_0  # increment, +tive
 #   _lat_lo = _0_0  # lower lat, south
@@ -1621,7 +1621,7 @@ class _PGM(_Gpars):
 
 
 class PGMError(GeoidError):
-    '''Issue parsing or cropping an C{egm*.pgm} geoid dataset.
+    '''An issue while parsing or cropping an C{egm*.pgm} geoid dataset.
     '''
     pass
 

pygeodesy/heights.py

@@ -91,7 +91,7 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '24.08.24'
+__version__ = '24.11.02'
 
 _error_  = 'error'
 _formy   = _MODS.into(formy=__name__)
@@ -1031,7 +1031,7 @@ class HeightIDWkarney(_HeightIDW):
        <https://WikiPedia.org/wiki/Inverse_distance_weighting>} (IDW) and the
        I{angular} distance in C{degrees} from I{Karney}'s U{geographiclib
        <https://PyPI.org/project/geographiclib>} method U{Geodesic.Inverse
-       <https://geographiclib.sourceforge.io/Python/doc/code.html#
+       <https://GeographicLib.SourceForge.io/Python/doc/code.html#
        geographiclib.geodesic.Geodesic.Inverse>}.
     '''
     def __init__(self, knots, beta=2, datum=None, **name__wrap):