pygeodesy 25.5.25__py2.py3-none-any.whl → 25.5.28__py2.py3-none-any.whl

pygeodesy/geodesicw.py

@@ -39,7 +39,7 @@ from contextlib import contextmanager
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.geodesicw
-__version__ = '25.04.14'
+__version__ = '25.05.28'
 
 _plumb_ = 'plumb'
 _TRIPS  =  65
@@ -96,6 +96,28 @@ class _gWrapped(_kWrapped):
                 if name:
                     self._name, _ = _name2__(name, _or_nameof=E)
 
+            def Area(self, polyline=False, **name):  # like GeodesicExact.Area
+                '''Return a C{PolygonArea} instance with method C{Compute} extended.
+                '''
+                _AreaBase = _wrapped._PolygonArea  # in .karney._kwrapped
+
+                class _PolygonArea(_AreaBase):
+                    # def __init__(self, *earth_polyline):
+                    #     _PolygonArea.__init__(self, *earth_polyline)
+
+                    def Compute(self, reverse=False, sign=True, polar=False):
+                        '''Use C{B{polar}=True} to adjust the area, see function
+                           L{areaOf<pygeodesy.geodesicx.gxarea.areaOf>}.
+                        '''
+                        n, p, a = _AreaBase.Compute(self, reverse=reverse, sign=sign)
+                        if polar:  # see .geodesicx.gxarea.GeodesicAreaExact._reduced
+                            a += _copysign(self.area0 * _0_5 * n, a)
+                        return n, p, a
+
+                A = _PolygonArea(self, polyline)
+                A.name = _name2__(name, _or_nameof=self)
+                return A
+
             def ArcDirect(self, lat1, lon1, azi1, a12, outmask=Caps.STANDARD):  # PYCHOK no cover
                 '''Return the C{_Geodesic.ArcDirect} result as L{GDict}.
                 '''
@@ -108,8 +130,6 @@ class _gWrapped(_kWrapped):
                 '''
                 return self._GenDirectLine(lat1, lon1, azi1, True, a12, caps, **name)
 
-            Area = _Geodesic.Polygon  # like GeodesicExact.Area
-
             @property_RO
             def datum(self):
                 '''Get this geodesic's datum (C{Datum}).
@@ -257,9 +277,8 @@ class _gWrapped(_kWrapped):
                 '''
                 return self._name
 
-#           Polygon = _Geodesic.Polygon
-
-            WGS84 = None  # _EWGS84.geodesicw recusion
+            Polygon = Area
+            WGS84   = None  # _EWGS84.geodesicw recusion
 
         # Geodesic.ArcDirect.__doc__   = _Geodesic.ArcDirect.__doc__
         # Geodesic.Direct.__doc__      = _Geodesic.Direct.__doc__
@@ -461,7 +480,7 @@ class Geodesic(_gWrapped):  # overwritten by 1st instance
            @kwarg name: Optional C{B{name}=NN} (C{str}).
         '''
         g = _wrapped.Geodesic(a_ellipsoid, f=f, **name)
-        _MODS.geodesicw.Geodesic = g.__class__  # overwrite class
+        _MODS.geodesicw.Geodesic = type(g)  # overwrite class
         return g
 
 
@@ -485,7 +504,7 @@ class GeodesicLine(_gWrapped):  # overwritten by 1st instance
            @kwarg name: Optional C{B{name}=NN} (C{str}).
         '''
         gl = _wrapped.GeodesicLine(geodesic, lat1, lon1, azi1, caps=caps, **name)
-        _MODS.geodesicw.GeodesicLine = gl.__class__  # overwrite class
+        _MODS.geodesicw.GeodesicLine = type(gl)  # overwrite class
         return gl
 
 

pygeodesy/geodesicx/gx.py

@@ -44,11 +44,11 @@ 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,  Fmt
+from pygeodesy.fmath import fdot_, hypot, hypot2,  Fmt
 from pygeodesy.fsums import fsumf_, fsum1f_
 from pygeodesy.geodesicx.gxbases import _cosSeries, _GeodesicBase, \
                                         _sincos12, _sin1cos2, _sinf1cos2d, \
-                                        _TINY, _xnC4
+                                        _TINY, _toNAN, _xnC4
 from pygeodesy.geodesicx.gxline import _GeodesicLineExact, _update_glXs
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _DOT_, _UNDER_
@@ -65,7 +65,7 @@ from pygeodesy.utily import atan2, atan2d as _atan2d_reverse, _unrollon, \
 from math import copysign, cos, degrees, fabs, radians, sqrt
 
 __all__ = ()
-__version__ = '25.05.12'
+__version__ = '25.05.28'
 
 _MAXIT1 = 20
 _MAXIT2 = 10 + _MAXIT1 + MANT_DIG  # MANT_DIG == C++ digits
@@ -96,15 +96,12 @@ def _eTOL2(f):
     # (bet1 + bet2) / 2, the relative error in the azimuth
     # consistency check is sig12^2 * abs(f) * min(1, 1-f/2) / 2.
     # (Error measured for 1/100 < b/a < 100 and abs(f) >= 1/1000.
-
-    # For a given f and sig12, the max error occurs for lines
-    # near the pole.  If the old rule for computing dnm = (dn1
-    # + dn2)/2 is used, then the error increases by a factor of
-    # 2.)  Setting this equal to epsilon gives sig12 = etol2.
-
-    # Here 0.1 is a safety factor (error decreased by 100) and
-    # max(0.001, abs(f)) stops etol2 getting too large in the
-    # nearly spherical case.
+    #  For a given f and sig12, the max error occurs for lines
+    #  near the pole.  If the old rule for computing dnm = (dn1 +
+    #  dn2)/2 is used, then the error increases by a factor of 2.)
+    # Setting this equal to epsilon gives sig12 = eTOL2.  Here,
+    # safety factor 0.1 (error decreased by 100) and max(0.001, abs(f))
+    # stops eTOL2 getting too large in the nearly spherical case.
     t = min(_1_0, _1_0 - f * _0_5) * max(_0_001, fabs(f)) * _0_5
     return _TOL3 / (sqrt(t) if t > EPS02 else EPS0)
 
@@ -216,11 +213,10 @@ class GeodesicExact(_GeodesicBase):
         return GeodesicLineExact(self, lat1, lon1, azi1, caps=caps, **name)._GenSet(self._debug, a12=a12)
 
     def Area(self, polyline=False, **name):
-        '''Set up a L{GeodesicAreaExact} to compute area and
-           perimeter of a polygon.
+        '''Set up a L{GeodesicAreaExact} to compute area and perimeter of a polygon.
 
-           @kwarg polyline: If C{True}, compute the perimeter only, otherwise
-                            the perimeter and area (C{bool}).
+           @kwarg polyline: If C{True}, compute the perimeter only, otherwise the
+                            perimeter and area (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicAreaExact} instance.
@@ -429,17 +425,21 @@ class GeodesicExact(_GeodesicBase):
     def _eF_reset_cHe2_f1(self, x, y):
         '''(INTERNAL) Reset elliptic function and return M{cH * e2 / f1 * ...}.
         '''
-        self._eF_reset_k2(x)
-        return y * self._eF.cH * self._e2_f1
+        if isnan(x):
+            y = NAN
+        else:
+            self._eF_reset_k2(x)
+            y *= self._eF.cH * self._e2_f1
+        return y
 
     def _eF_reset_k2(self, x):
         '''(INTERNAL) Reset elliptic function and return C{k2}.
         '''
         ep2 = self.ep2
-        k2  = x**2 * ep2  # see .gxline._GeodesicLineExact._eF
-        self._eF.reset(k2=-k2, alpha2=-ep2)  # kp2, alphap2 defaults
+        x  *= x * ep2  # see .gxline._GeodesicLineExact._eF
+        self._eF.reset(k2=-x, alpha2=-ep2)  # kp2, alphap2 defaults
         _update_glXs(self)  # zap cached/memoized _GeodesicLineExact attrs
-        return k2
+        return x
 
     @Property_RO
     def ellipsoid(self):
@@ -499,6 +499,7 @@ class GeodesicExact(_GeodesicBase):
         if self._debug:  # PYCHOK no cover
             outmask |= Cs._DEBUG_INVERSE & self._debug
         outmask &= Cs._OUT_MASK  # incl. _SALP_CALPs_ and _DEBUG_
+        toNAN = _toNAN(outmask, lat1, lon1, lat2, lon2)
         # compute longitude difference carefully (with _diff182):
         # result is in [-180, +180] but -180 is only for west-going
         # geodesics, +180 is for east-going and meridional geodesics
@@ -700,7 +701,9 @@ class GeodesicExact(_GeodesicBase):
                         eFk2=eF.k2, eFa2=eF.alpha2)
             p.update(r)  # r overrides p
             r = p.toGDict()
-        return self._iter2tion(r, **p)
+
+        r = self._iter2tion(r, **p)
+        return r._toNAN(outmask) if toNAN else r
 
     def _GenDirect(self, lat1, lon1, azi1, arcmode, s12_a12, outmask=Caps.STANDARD):
         '''(INTERNAL) The general I{Inverse} geodesic calculation.
@@ -805,8 +808,7 @@ class GeodesicExact(_GeodesicBase):
                  <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1GeodesicExact.html>} and
                  Python U{Geodesic.InverseLine<https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
         '''
-        Cs = Caps
-        r  = self._GDictInverse(lat1, lon1, lat2, lon2, caps | Cs._SALP_CALPs_)
+        r = self._GDictInverse(lat1, lon1, lat2, lon2, caps | Caps._SALP_CALPs_)
         return GeodesicLineExact(self, lat1, lon1, None, caps=caps, _s_calp1=(r.salp1, r.calp1),
                                                             **name)._GenSet(self._debug, **r)
 
@@ -839,12 +841,12 @@ class GeodesicExact(_GeodesicBase):
             #                   (tan(bet1/2) + tan(bet2/2)) /
             #                   (tan(bet1/2) * tan(bet2/2) + 1))
             # with tan(x/2) = sin(x) / (1 + cos(x))
-            dbet1  =  p.cbet1 + _1_0
-            dbet2  =  p.cbet2 + _1_0
-            domg12 =   comg12 + _1_0
-            salp12 = (p.sbet1 *   dbet2 + dbet1 * p.sbet2) * somg12
-            calp12 = (p.sbet1 * p.sbet2 + dbet1 *   dbet2) * domg12
-            alp12  =  atan2(salp12, calp12) * _2_0
+            dbet1  = p.cbet1 + _1_0
+            dbet2  = p.cbet2 + _1_0
+            domg12 =  comg12 + _1_0
+            salp12 = fdot_(p.sbet1,   dbet2, dbet1, p.sbet2) * somg12
+            calp12 = fdot_(p.sbet1, p.sbet2, dbet1,   dbet2) * domg12
+            alp12  = atan2(salp12, calp12) * _2_0
         else:
             # alp12 = alp2 - alp1, used in atan2, no need to normalize
             salp12, calp12 = _sincos12(salp1, calp1, salp2, calp2)
@@ -870,7 +872,7 @@ class GeodesicExact(_GeodesicBase):
                     and C{p.set_sigs} updated for Newton, C{sig12=None}.
         '''
         sig12 = None  # use Newton
-        salp1 = calp1 = salp2 = calp2 = dnm = NAN
+        salp1 = calp1 = salp2 = calp2 = NAN
 
         # bet12 = bet2 - bet1 in [0, PI)
         sbet12, cbet12 = _sincos12(p.sbet1, p.cbet1, p.sbet2, p.cbet2)
@@ -878,12 +880,15 @@ class GeodesicExact(_GeodesicBase):
         if shortline:
             # sin((bet1 + bet2)/2)^2 = (sbet1 + sbet2)^2 / (
             #      (cbet1 + cbet2)^2 + (sbet1 + sbet2)^2)
-            t = (p.sbet1 + p.sbet2)**2
-            s = t / ((p.cbet1 + p.cbet2)**2 + t)
-            dnm = sqrt(_1_0 + self.ep2 * s)
+            t = p.sbet1 + p.sbet2
+            if t:
+                t *= t / hypot2(t, p.cbet1 + p.cbet2)
+                dnm =  sqrt(self.ep2 * t + _1_0)
+            else:
+                dnm = _1_0
             somg12, comg12 = _sincos2(lam12 / (self.f1 * dnm))
         else:
-            somg12, comg12 = p.slam12, p.clam12
+            somg12, comg12, dnm = p.slam12, p.clam12, NAN
 
         # bet12a = bet2 + bet1 in (-PI, 0], note -sbet1
         sbet12a, cbet12a = _sincos12(-p.sbet1, p.cbet1, p.sbet2, p.cbet2)
@@ -894,8 +899,8 @@ class GeodesicExact(_GeodesicBase):
         salp1 =  p.cbet2 * somg12
         calp1 = (sbet12a - t) if comg12 < 0 else (sbet12 + t)
 
-        ssig12 = _hypot(salp1, calp1)
-        csig12 =  p.sbet1 * p.sbet2 + p.cbet1 * p.cbet2 * comg12
+        ssig12 = hypot(salp1, calp1)
+        csig12 = fdot_(p.sbet1, p.sbet2, p.cbet1, p.cbet2 * comg12)
 
         if shortline and ssig12 < self._eTOL2:  # really short lines
             t = c if comg12 < 0 else s
@@ -970,8 +975,8 @@ class GeodesicExact(_GeodesicBase):
                 #
                 # omg12 is near PI, estimate work with omg12a = PI - omg12
                 k    = _Astroid(x, y)
-                sca *= (y * (k + _1_0) / k) if f < 0 else \
-                       (x *  k / (k + _1_0))
+                k1   = _1_0 + k
+                sca *= (y * k1 / k) if f < 0 else (x * k / k1)
                 s, c = _sincos2(-sca)  # omg12a
                 # update spherical estimate of alp1 using omg12 instead of lam12
                 salp1 = p.cbet2 * s
@@ -1082,16 +1087,15 @@ class GeodesicExact(_GeodesicBase):
                 # Missing a factor of self.b.  Add parens around
                 # (csig1 * ssig2) and (ssig1 * csig2) to ensure
                 # accurate cancellation for coincident points.
-                m12b = fsum1f_(p.dn2 * (p.csig1 * p.ssig2),
-                              -p.dn1 * (p.ssig1 * p.csig2),
-                                 J12 * (p.csig1 * p.csig2))
+                m12b = fdot_(p.dn2, (p.csig1 * p.ssig2),
+                            -p.dn1, (p.ssig1 * p.csig2),
+                               J12, (p.csig1 * p.csig2))
             if (outmask & Cs.GEODESICSCALE):
-                M12 = M21 = p.ssig1 * p.ssig2 + \
-                            p.csig1 * p.csig2
+                M12 = M21 = fdot_(p.ssig1, p.ssig2, p.csig1, p.csig2)
                 t = (p.cbet1 - p.cbet2) * self.ep2 * \
                     (p.cbet1 + p.cbet2) / (p.dn1 + p.dn2)
-                M12 += (p.ssig2 * t + p.csig2 * J12) * p.ssig1 / p.dn1
-                M21 -= (p.ssig1 * t + p.csig1 * J12) * p.ssig2 / p.dn2
+                M12 += fdot_(p.ssig2, t, p.csig2, J12) * p.ssig1 / p.dn1
+                M21 -= fdot_(p.ssig1, t, p.csig1, J12) * p.ssig2 / p.dn2
 
         return s12b, m12b, m0, M12, M21
 
@@ -1310,7 +1314,7 @@ def _Astroid(x, y):
             u = _cbrt(S * _2_0)  # == T3 + _copysign(abs(S), T3)
         else:
             u = _0_0
-        v = _hypot(u, y)  # sqrt(u**2 + q)
+        v = hypot(u, y)  # sqrt(u**2 + q)
         # avoid loss of accuracy when u < 0
         u = (q / (v - u)) if u < 0 else (v + u)
         w = (u - q) / (v + v)  # positive?

pygeodesy/geodesicx/gxarea.py

@@ -17,7 +17,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 # make sure int/int division yields float quotient
 from __future__ import division as _; del _  # noqa: E702 ;
 
-from pygeodesy.basics import isodd, unsigned0
+from pygeodesy.basics import _copysign, isodd, unsigned0
 from pygeodesy.constants import NAN, _0_0, _0_5, _720_0
 from pygeodesy.internals import printf, typename
 # from pygeodesy.interns import _COMMASPACE_  # from .lazily
@@ -31,19 +31,16 @@ from pygeodesy.props import Property, Property_RO, property_RO
 from math import fmod as _fmod
 
 __all__ = ()
-__version__ = '25.05.12'
+__version__ = '25.05.28'
 
 
 class GeodesicAreaExact(_NamedBase):
-    '''Area and perimeter of a geodesic polygon, an enhanced
-       version of I{Karney}'s Python class U{PolygonArea
-       <https://GeographicLib.SourceForge.io/html/python/
-       code.html#module-geographiclib.polygonarea>} using
-       the more accurate surface area.
-
-       @note: The name of this class C{*Exact} is a misnomer, see
-              I{Karney}'s comments at C++ attribute U{GeodesicExact._c2
-              <https://GeographicLib.SourceForge.io/C++/doc/
+    '''Area and perimeter of a geodesic polygon, an enhanced version of I{Karney}'s
+       Python class U{PolygonArea<https://GeographicLib.SourceForge.io/html/python/
+       code.html#module-geographiclib.polygonarea>} using the more accurate surface area.
+
+       @note: The name of this class C{*Exact} is a misnomer, see I{Karney}'s comments at
+              C++ attribute U{GeodesicExact._c2<https://GeographicLib.SourceForge.io/C++/doc/
               GeodesicExact_8cpp_source.html>}.
     '''
     _Area    =  None
@@ -140,36 +137,35 @@ class GeodesicAreaExact(_NamedBase):
 
     @Property_RO
     def area0x(self):
-        '''Get the ellipsoid's surface area (C{meter} I{squared}),
-           more accurate for very I{oblate} ellipsoids.
+        '''Get the ellipsoid's surface area (C{meter} I{squared}), more accurate
+           for very I{oblate} ellipsoids.
         '''
         return self.ellipsoid.areax  # not .area!
 
     area0 = area0x  # for C{geographiclib} compatibility
 
-    def Compute(self, reverse=False, sign=True):
+    def Compute(self, reverse=False, sign=True, polar=False):
         '''Compute the accumulated perimeter and area.
 
-           @kwarg reverse: If C{True}, clockwise traversal counts as a
-                           positive area instead of counter-clockwise
-                           (C{bool}).
-           @kwarg sign: If C{True}, return a signed result for the area if
-                        the polygon is traversed in the "wrong" direction
-                        instead of returning the area for the rest of the
-                        earth.
-
-           @return: L{Area3Tuple}C{(number, perimeter, area)} with the
-                    number of points, the perimeter in C{meter} and the
-                    area in C{meter**2}.  The perimeter includes the
-                    length of a final edge, connecting the current to
-                    the initial point, if this polygon was initialized
-                    with C{polyline=False}.  For perimeter only, i.e.
-                    C{polyline=True}, area is C{NAN}.
-
-           @note: Arbitrarily complex polygons are allowed.  In the case
-                  of self-intersecting polygons, the area is accumulated
-                  "algebraically".  E.g., the areas of the 2 loops in a
-                  I{figure-8} polygon will partially cancel.
+           @kwarg reverse: If C{True}, clockwise traversal counts as a positive area instead
+                           of counter-clockwise (C{bool}).
+           @kwarg sign: If C{True}, return a signed result for the area if the polygon is
+                        traversed in the "wrong" direction instead of returning the area for
+                        the rest of the earth.
+           @kwarg polar: Use C{B{polar}=True} if the polygon encloses a pole (C{bool}), see
+                         function L{ispolar<pygeodesy.points.ispolar>} and U{area of a polygon
+                         enclosing a pole<https://GeographicLib.SourceForge.io/C++/doc/
+                         classGeographicLib_1_1GeodesicExact.html#a3d7a9155e838a09a48dc14d0c3fac525>}.
+
+           @return: L{Area3Tuple}C{(number, perimeter, area)} with the number of points, the
+                    perimeter in C{meter} and the (signed) area in C{meter**2}.  The perimeter
+                    includes the length of a final edge, connecting the current to the initial
+                    point, if this polygon was initialized with C{polyline=False}.  For perimeter
+                    only, i.e. C{polyline=True}, area is C{NAN}.
+
+           @note: Arbitrarily complex polygons are allowed.  In the case of self-intersecting
+                  polygons, the area is accumulated "algebraically".  E.g., the areas of both
+                  loops in a I{figure-8} polygon will partially cancel.
 
            @note: More points and edges can be added after this call.
         '''
@@ -179,7 +175,7 @@ class GeodesicAreaExact(_NamedBase):
             a = NAN if self.polyline else p
         elif self._Area:
             r = self._Inverse(self.lat1, self.lon1, self.lat0, self.lon0)
-            a = self._reduced(r.S12, reverse, sign, r.xing)
+            a = self._reduced(r.S12, r.xing, n, reverse=reverse, sign=sign, polar=polar)
             p = self._Peri.Sum(r.s12)
         else:
             p = self._Peri.Sum()
@@ -279,7 +275,7 @@ class GeodesicAreaExact(_NamedBase):
         t = _COMMASPACE_.join(pairs(d, prec=10))
         printf('%s %s: %s (%s)', self.named2, n, t, callername(up=2))
 
-    def _reduced(self, S12, reverse, sign, xing):
+    def _reduced(self, S12, xing, n, reverse=False, sign=True, polar=False):
         '''(INTERNAL) Accumulate and reduce area to allowed range.
         '''
         a0 =  self.area0x
@@ -296,6 +292,8 @@ class GeodesicAreaExact(_NamedBase):
             a = A.Add(-a0)
         elif a <= -a0_:
             a = A.Add( a0)
+        if polar:  # see .geodesicw._gwrapped.Geodesic.Area
+            a = A.Add(_copysign(a0 * _0_5 * n, a))  # - if reverse or sign?
         return unsigned0(a)
 
     def Reset(self):
@@ -313,63 +311,54 @@ class GeodesicAreaExact(_NamedBase):
 
     Clear = Reset
 
-    def TestEdge(self, azi, s, reverse=False, sign=True):
+    def TestEdge(self, azi, s, **reverse_sign_polar):
         '''Compute the properties for a tentative, additional edge
 
            @arg azi: Azimuth at the current the point (compass C{degrees}).
            @arg s: Length of the edge (C{meter}).
-           @kwarg reverse: If C{True}, clockwise traversal counts as a
-                           positive area instead of counter-clockwise
-                           (C{bool}).
-           @kwarg sign: If C{True}, return a signed result for the area if
-                        the polygon is traversed in the "wrong" direction
-                        instead of returning the area for the rest of the
-                        earth.
+           @kwarg reverse_sign_polar: Optional C{B{reverse}=False}, C{B{sign}=True} and
+                          C{B{polar}=False} keyword arguments, see method L{Compute}.
 
            @return: L{Area3Tuple}C{(number, perimeter, area)}.
 
            @raise GeodesicError: No points.
         '''
-        n = self.num + 1
-        p = self._Peri.Sum(s)
-        if self.polyline:
-            a, r = NAN, None
-        elif n < 2:
-            raise GeodesicError(num=self.num)
+        r, n = None, self.num + 1
+        if n < 2:  # raise GeodesicError(num=self.num)
+            a = p = NAN  # like .test_Planimeter19
         else:
-            d  = self._Direct(azi, s)
-            r  = self._Inverse(d.lat2, d.lon2, self.lat0, self.lon0)
-            a  = self._reduced(d.S12 + r.S12, reverse, sign, d.xing + r.xing)
-            p += r.s12
+            p = self._Peri.Sum(s)
+            if self.polyline:
+                a  = NAN
+            else:
+                d  = self._Direct(azi, s)
+                r  = self._Inverse(d.lat2, d.lon2, self.lat0, self.lon0)
+                a  = self._reduced(d.S12 + r.S12, d.xing + r.xing, n, **reverse_sign_polar)
+                p += r.s12
         if self.verbose:  # PYCHOK no cover
             self._print(n, p, a, r, azi=azi, s=s)
         return Area3Tuple(n, p, a)
 
-    def TestPoint(self, lat, lon, reverse=False, sign=True):
+    def TestPoint(self, lat, lon, **reverse_sign_polar):
         '''Compute the properties for a tentative, additional vertex
 
            @arg lat: Latitude of the point (C{degrees}).
            @arg lon: Longitude of the point (C{degrees}).
-           @kwarg reverse: If C{True}, clockwise traversal counts as a
-                           positive area instead of counter-clockwise
-                           (C{bool}).
-           @kwarg sign: If C{True}, return a signed result for the area if
-                        the polygon is traversed in the "wrong" direction
-                        instead of returning the area for the rest of the
-                        earth.
+           @kwarg reverse_sign_polar: Optional C{B{reverse}=False}, C{B{sign}=True} and
+                          C{B{polar}=False} keyword arguments, see method L{Compute}.
 
            @return: L{Area3Tuple}C{(number, perimeter, area)}.
         '''
         r, n = None, self.num + 1
         if n < 2:
             p = _0_0
-            a = NAN if self.polyline else p
+            a =  NAN if self.polyline else p
         else:
             i = self._Inverse(self.lat1, self.lon1, lat, lon)
             p = self._Peri.Sum(i.s12)
             if self._Area:
                 r  = self._Inverse(lat, lon, self.lat0, self.lon0)
-                a  = self._reduced(i.S12 + r.S12, reverse, sign, i.xing + r.xing)
+                a  = self._reduced(i.S12 + r.S12, i.xing + r.xing, n, **reverse_sign_polar)
                 p += r.s12
             else:
                 a = NAN

pygeodesy/geodesicx/gxbases.py

@@ -9,7 +9,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 '''
 
 from pygeodesy.basics import isodd,  _MODS
-from pygeodesy.constants import _EPSmin as _TINY, _0_0
+from pygeodesy.constants import _EPSmin as _TINY, _0_0, isfinite
 from pygeodesy.errors import _or, _xkwds_item2
 from pygeodesy.fmath import hypot as _hypot
 # from pygeodesy.interns import _numpy_  # _MODS
@@ -20,7 +20,7 @@ from pygeodesy.karney import _CapsBase, GeodesicError, _2cos2x, \
 from math import fabs, ldexp as _ldexp
 
 __all__ = ()
-__version__ = '24.09.07'
+__version__ = '25.05.28'
 
 # valid C{nC4}s and C{C4order}s, see _xnC4 below
 _nC4s = {24: 2900, 27: 4032, 30: 5425}
@@ -147,6 +147,16 @@ def _sinf1cos2d(lat, f1):
     return sbet, (cbet if fabs(cbet) > _TINY else _TINY)
 
 
+def _toNAN(outmask, *args):
+    '''(INTERNAL) Is any C{arg} not finite?
+    '''
+    if (outmask & _CapsBase.NONFINITONAN):  # Caps.NONFINITONAN
+        for arg in args:
+            if not isfinite(arg):
+                return True
+    return False
+
+
 def _xnC4(**name_nC4):
     '''(INTERNAL) Validate C{C4order}.
     '''

pygeodesy/geodesicx/gxline.py

@@ -37,13 +37,14 @@ from __future__ import division as _; del _  # noqa: E702 ;
 # - s and c prefixes mean sin and cos
 
 # from pygeodesy.basics import _xinstanceof  # _MODS
-from pygeodesy.constants import NAN, _EPSqrt as _TOL, _0_0, _1_0, \
-                               _180_0, _2__PI, _copysign_1_0, isfinite
+from pygeodesy.constants import NAN, _EPSqrt as _TOL, \
+                               _0_0, _1_0, _180_0, _2__PI, \
+                               _copysign_1_0, isfinite
 from pygeodesy.errors import _xError, _xkwds_pop2
 from pygeodesy.fsums import fsumf_, fsum1f_
 from pygeodesy.geodesicx.gxbases import _cosSeries, _GeodesicBase, \
                                         _sincos12, _sin1cos2, \
-                                        _sinf1cos2d, _TINY
+                                        _sinf1cos2d, _TINY, _toNAN
 # from pygeodesy.geodesicw import _Intersecant2  # _MODS
 from pygeodesy.lazily import _ALL_DOCS, _ALL_MODS as _MODS
 from pygeodesy.karney import _around, _atan2d, Caps, GDict, _fix90, \
@@ -55,7 +56,7 @@ from pygeodesy.utily import atan2, atan2d as _atan2d_reverse, sincos2
 from math import cos, degrees, fabs, floor, radians, sin
 
 __all__ = ()
-__version__ = '25.05.12'
+__version__ = '25.05.28'
 
 _glXs = []  # instances of C{[_]GeodesicLineExact} to be updated
 
@@ -91,6 +92,7 @@ class _GeodesicLineExact(_GeodesicBase):
 #   _salp1 = _calp1 = NAN
 #   _somg1 = _comg1 = NAN
 #   _ssig1 = _csig1 = NAN
+#   _toNAN =  False
 
     def __init__(self, gX, lat1, lon1, azi1, caps, **name_):
         '''(INTERNAL) New C{[_]GeodesicLineExact} instance.
@@ -104,6 +106,7 @@ class _GeodesicLineExact(_GeodesicBase):
             salp1, calp1 = _sincos2d(_around(azi1))
         if name_:
             self.name = name_
+        self._toNAN = _toNAN(caps, lat1, lon1, azi1, salp1, calp1)
 
         self._gX    = gX  # GeodesicExact only
         self._lat1  = lat1 = _fix90(lat1)
@@ -297,9 +300,9 @@ class _GeodesicLineExact(_GeodesicBase):
         gX = self.geodesic  # ._gX
         r  = GDict(a12=NAN, s12=NAN)  # both a12 and s12, always
 
-        if not isfinite(s12_a12):
+        if self._toNAN or not isfinite(s12_a12):  # _toNAN(outmask, s12_a12)?
             # E2 = sig12 = ssig12 = csig12 = NAN
-            return r._toNAN(outmask)
+            return r._toNAN(outmask | Cs.NONFINITONAN)  # for backward compatibility
         elif arcmode:  # s12_a12 is (spherical) arc length
             r.set_(a12=s12_a12)
             sig12 = radians(s12_a12)

pygeodesy/geoids.py

@@ -355,7 +355,7 @@ class _GeoidBase(_HeightBase):
         # build grid axis, hi = lo + (n - 1) * d
         m, a = len2(frange(lo, n, d))
         if m != n:
-            raise LenError(self.__class__, grid=m, **{name: n})
+            raise LenError(type(self), grid=m, **{name: n})
         if d < 0:
             d, a = -d, list(reversed(a))
         a = self.numpy.array(a)

pygeodesy/hausdorff.py

@@ -85,7 +85,7 @@ from pygeodesy import unitsBase as _unitsBase  # _Str_..., _xUnit, _xUnits
 from random import Random
 
 __all__ = _ALL_LAZY.hausdorff
-__version__ = '25.05.21'
+__version__ = '25.05.26'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -124,7 +124,7 @@ class Hausdorff(_Named):
            @raise HausdorffError: Insufficient number of B{C{point1s}} or an invalid
                                   B{C{point1}}, B{C{seed}} or B{C{units}}.
         '''
-        name, kwds = _name2__(**name__kwds)  # name__=self.__class__
+        name, kwds = _name2__(**name__kwds)  # name__=type(self)
         if name:
             self.name = name
 

pygeodesy/heights.py

@@ -92,7 +92,7 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '25.05.12'
+__version__ = '25.05.26'
 
 _error_  = 'error'
 _formy   = _MODS.into(formy=__name__)
@@ -212,7 +212,7 @@ class _HeightNamed(_Named):  # in .geoids
             n, lats = len2(lats)
             m, lons = len2(lons)
             if n != m:  # format a LenError, but raise self._Error
-                e = LenError(self.__class__, lats=n, lons=m, txt=None)
+                e = LenError(type(self), lats=n, lons=m, txt=None)
                 raise self._Error(str(e))
             llis = [LLiC(*t, datum=d) for t in zip(lats, lons)]
         return llis
@@ -363,13 +363,13 @@ class _HeightBase(_HeightNamed):  # in .geoids
     def numpy(self):
         '''Get the C{numpy} module or C{None}.
         '''
-        return _xnumpy(self.__class__, 1, 9)  # overwrite property_ROver
+        return _xnumpy(type(self), 1, 9)  # overwrite property_ROver
 
     @property_ROver
     def scipy(self):
         '''Get the C{scipy} module or C{None}.
         '''
-        return _xscipy(self.__class__, 1, 2)  # overwrite property_ROver
+        return _xscipy(type(self), 1, 2)  # overwrite property_ROver
 
     @property_ROver
     def scipy_interpolate(self):