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

pygeodesy/__init__.py

@@ -604,7 +604,7 @@ else:
 
 from pygeodesy.internals import _version2,  _DOT_  # noqa: E402
 # from pygeodesy.interns import _DOT_  # from .internals
-__version__ = '25.05.25'
+__version__ = '25.05.28'
 # see setup.py for similar logic
 version     = _DOT_(*_version2(__version__, n=3))
 

pygeodesy/__main__.py

@@ -5,7 +5,7 @@ u'''Print L{pygeodesy} version, etc. using C{python -m pygeodesy}.
 '''
 
 __all__ = ()
-__version__ = '25.04.12'
+__version__ = '25.06.26'
 
 from os.path import basename, dirname
 
@@ -28,6 +28,7 @@ def _main():  # PYCHOK no cover
                                  ('isLazy',                       isLazy),
                                  ('_isfrozen',                 _isfrozen),
                                  ('_floats',      len(constants._floats)),
+#                                ('_interns', len(interns.__dict__) - 22),
                                  (_DALL_,            len(_all_imports())),
                                  (_DEPRECATED_,   len(_all_deprecates()))))
 

pygeodesy/booleans.py

@@ -45,7 +45,7 @@ from pygeodesy.utily import fabs, _unrollon, _Wrap
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.booleans
-__version__ = '25.05.12'
+__version__ = '25.05.26'
 
 _0EPS  =  EPS  # near-zero, positive
 _EPS0  = -EPS  # near-zero, negative
@@ -199,8 +199,8 @@ class _LatLonBool(_Named):
 
     def __sub__(self, other):
         _other(self, other)
-        return self.__class__(self.y - other.y,  # classof
-                              self.x - other.x)
+        return type(self)(self.y - other.y,  # classof
+                          self.x - other.x)
 
     def _2A(self, p2, p3):
         # I{Signed} area of a triangle, I{doubled}.
@@ -314,7 +314,7 @@ class LatLonFHP(_LatLonBool):
 
     def __add__(self, other):
         _other(self, other)
-        return self.__class__(self.y + other.y, self.x + other.x)
+        return type(self)(self.y + other.y, self.x + other.x)
 
     def __mod__(self, other):  # cross product
         _other(self, other)
@@ -326,7 +326,7 @@ class LatLonFHP(_LatLonBool):
 
     def __rmul__(self, other):  # scalar product
         _xscalar(other=other)
-        return self.__class__(self.y * other, self.x * other)
+        return type(self)(self.y * other, self.x * other)
 
 #   def _edge2(self):
 #       # Return the start and end point of the
@@ -959,7 +959,7 @@ class _CompositeBase(_Named):
         # Return a new instance
         _g = kwds.get
         kwds = dict((n, _g(n, v)) for n, v in dflts.items())
-        return self.__class__(corners or (), **kwds)
+        return type(self)(corners or (), **kwds)
 
     @property_RO
     def _clipids(self):  # PYCHOK no cover
@@ -1549,7 +1549,7 @@ class _EdgeFHP(object):
             dq  = q2 - q1
             dq2 = dq * dq  # dot product, hypot2
             if dq2 > EPS2:  # like ._clip
-                T, _E  = None, _EdgeFHP  # self.__class__
+                T, _E  = None, _EdgeFHP  # type(self)
                 p1, p2 = self._p1_p2
                 ap1   = p1._2A(q1, q2)
                 ap2_1 = p2._2A(q1, q2) - ap1
@@ -1750,8 +1750,8 @@ class _BooleanBase(object):
 
     def _boolean4(self, other, op):
         # Set up a new C{Boolean[FHP|GH]}.
-        C = self.__class__
-        kwds = C._kwds(self, op)
+        C = type(self)
+        kwds = C._kwds(self, op)  # PYCHOK in _Composite[FHP|GH]
         a =  C(self, **kwds)
         b = _other(self, other)
         return a, b, C, kwds
@@ -1964,7 +1964,7 @@ def _min_max_eps2(*xs):
 def _other(this, other):
     '''(INTERNAL) Check for compatible C{type}s.
     '''
-    C = this.__class__
+    C = type(this)
     if isinstance(other, C):
         return other
     raise _IsnotError(C, other=other)

pygeodesy/constants.py

@@ -1,8 +1,8 @@
 
 # -*- coding: utf-8 -*-
 
-u'''Single-instance C{float} and C{int} constants across C{pygeodesy} modules and
-related functions L{pygeodesy.float_}, L{pygeodesy.isclose}, L{pygeodesy.isfinite},
+u'''Single-instance C{float} and C{int} constants across C{pygeodesy} modules and related
+functions L{pygeodesy.float_}, L{pygeodesy.float0_}, L{pygeodesy.isclose}, L{pygeodesy.isfinite},
 L{pygeodesy.isinf}, L{pygeodesy.isint0}, L{pygeodesy.isnan}, L{pygeodesy.isnear0},
 L{pygeodesy.isnear1}, L{pygeodesy.isnear90}, L{pygeodesy.isneg0}, L{pygeodesy.isninf},
 L{pygeodesy.isnon0} and L{pygeodesy.remainder}.
@@ -26,7 +26,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '25.05.12'
+__version__ = '25.05.26'
 
 
 def _copysign_0_0(y):
@@ -495,12 +495,12 @@ def _umod_PI2(rad):
 
 if __name__ == _DMAIN_:
 
-    def _main(locals):
+    def _main(globalocals):
         from pygeodesy import itemsorted, printf
         from pygeodesy.interns import _DALL_, _UNDER_
 
         t = n = v = []
-        for n, v in itemsorted(locals):
+        for n, v in itemsorted(globalocals):
             if isinstance(v, (Float, Int, Radius)):
                 printf('%9s: %r', n, v.toRepr(std=False))
                 if v.name != n:
@@ -512,7 +512,7 @@ if __name__ == _DMAIN_:
         t.append(typename(float_))
         printf('%s = %r', _DALL_, tuple(t))
 
-    _main(locals())
+    _main(globals())  # or locals()
 
 # **) MIT License
 #

pygeodesy/css.py

@@ -470,7 +470,7 @@ class Css(_NamedBase):
 #                                h=self.height, cs0=self.cs0,
 #                                name=_name__(name, _or_nameof(self)))
 #       args, kwds = _args_kwds(**kwds)
-#       return self.__class__(*args, **kwds)  # .classof
+#       return type(self)(*args, **kwds)  # .classof
 
     @Property_RO
     def easting(self):

pygeodesy/ellipsoidalExact.py

@@ -24,7 +24,7 @@ from pygeodesy.points import _areaError, ispolar  # PYCHOK exported
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalExact
-__version__ = '25.05.12'
+__version__ = '25.05.28'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -88,17 +88,19 @@ class LatLon(LatLonEllipsoidalBaseDI):
         return LatLonEllipsoidalBaseDI.toCartesian(self, **kwds)
 
 
-def areaOf(points, datum=_WGS84, wrap=True):
+def areaOf(points, datum=_WGS84, wrap=True, polar=False):
     '''Compute the area of an (ellipsoidal) polygon or composite.
 
-       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or
-                    L{BooleanGH}).
+       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}}
+                    (C{bool}).
+       @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: Area (C{meter} I{squared}, same units as the B{C{datum}}'s
-                ellipsoid axes).
+       @return: Area (C{meter} I{squared}, same units as the B{C{datum}}'s ellipsoid axes).
 
        @raise PointsError: Insufficient number of B{C{points}}.
 
@@ -110,12 +112,8 @@ def areaOf(points, datum=_WGS84, wrap=True):
        @see: Functions L{pygeodesy.areaOf}, L{ellipsoidalGeodSolve.areaOf},
              L{ellipsoidalKarney.areaOf}, L{sphericalNvector.areaOf} and
              L{sphericalTrigonometry.areaOf}.
-
-       @note: The U{area of a polygon enclosing a pole<https://GeographicLib.SourceForge.io/
-              C++/doc/classGeographicLib_1_1GeodesicExact.html#a3d7a9155e838a09a48dc14d0c3fac525>}
-              can be found by adding half the datum's ellipsoid surface area to the polygon's area.
     '''
-    return fabs(_polygon(datum.ellipsoid.geodesicx, points, True, False, wrap))
+    return fabs(_polygon(datum.ellipsoid.geodesicx, points, True, False, wrap, polar))
 
 
 def intersection3(start1, end1, start2, end2, height=None, wrap=False,  # was=True
@@ -216,13 +214,14 @@ def intersections2(center1, radius1, center2, radius2, height=None, wrap=False,
                                              equidistant=equidistant, tol=tol, **kwds)
 
 
-def isclockwise(points, datum=_WGS84, wrap=True):
+def isclockwise(points, datum=_WGS84, wrap=True, polar=False):
     '''Determine the direction of a path or polygon.
 
        @arg points: The path or polygon points (C{LatLon}[]).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
+       @kwarg polar: Use C{B{polar}=True} if the C{B{points}} enclose a pole (C{bool}),
+                     see function U{ispolar<pygeodeys.points.ispolar>}.
 
        @return: C{True} if B{C{points}} are clockwise, C{False} otherwise.
 
@@ -234,7 +233,7 @@ def isclockwise(points, datum=_WGS84, wrap=True):
 
        @see: L{pygeodesy.isclockwise}.
     '''
-    a = _polygon(datum.ellipsoid.geodesicx, points, True, False, wrap)
+    a = _polygon(datum.ellipsoid.geodesicx, points, True, False, wrap, polar)
     if a < 0:
         return True
     elif a > 0:
@@ -288,29 +287,25 @@ def nearestOn(point, point1, point2, within=True, height=None, wrap=False,
 def perimeterOf(points, closed=False, datum=_WGS84, wrap=True):
     '''Compute the perimeter of an (ellipsoidal) polygon or composite.
 
-       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or
-                    L{BooleanGH}).
+       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg closed: Optionally, close the polygon (C{bool}).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
 
-       @return: Perimeter (C{meter}, same units as the B{C{datum}}'s
-                ellipsoid axes).
+       @return: Perimeter (C{meter}, same units as the B{C{datum}}'s ellipsoid axes).
 
        @raise PointsError: Insufficient number of B{C{points}}.
 
        @raise TypeError: Some B{C{points}} are not L{LatLon}.
 
-       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled
-                          longitudes not supported or C{B{closed}=False}
-                          with C{B{points}} a composite.
+       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled longitudes not
+                          supported or C{B{closed}=False} with C{B{points}} a composite.
 
        @see: Functions L{pygeodesy.perimeterOf}, L{ellipsoidalGeodSolve.perimeterOf},
              L{ellipsoidalKarney.perimeterOf}, L{sphericalNvector.perimeterOf} and
              L{sphericalTrigonometry.perimeterOf}.
     '''
-    return _polygon(datum.ellipsoid.geodesicx, points, closed, True, wrap)
+    return _polygon(datum.ellipsoid.geodesicx, points, closed, True, wrap, False)
 
 
 __all__ += _ALL_OTHER(Cartesian, LatLon,  # classes

pygeodesy/ellipsoidalGeodSolve.py

@@ -24,7 +24,7 @@ from pygeodesy.points import _areaError, ispolar  # PYCHOK exported
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalGeodSolve
-__version__ = '24.08.13'
+__version__ = '25.05.28'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -87,12 +87,16 @@ class LatLon(LatLonEllipsoidalBaseDI):
         return LatLonEllipsoidalBaseDI.toCartesian(self, **kwds)
 
 
-def areaOf(points, datum=_WGS84, wrap=True):
+def areaOf(points, datum=_WGS84, wrap=True, polar=False):
     '''Compute the area of an (ellipsoidal) polygon or composite.
 
        @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg datum: Optional datum (L{Datum}).
        @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
+       @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: Area (C{meter}, same as units of the B{C{datum}}'s ellipsoid axes, I{squared}).
 
@@ -105,7 +109,7 @@ def areaOf(points, datum=_WGS84, wrap=True):
        @see: Functions L{pygeodesy.areaOf}, L{ellipsoidalExact.areaOf}, L{ellipsoidalKarney.areaOf},
              L{sphericalNvector.areaOf} and L{sphericalTrigonometry.areaOf}.
     '''
-    return fabs(_polygon(datum.ellipsoid.geodsolve, points, True, False, wrap))
+    return fabs(_polygon(datum.ellipsoid.geodsolve, points, True, False, wrap, polar))
 
 
 def intersection3(start1, end1, start2, end2, height=None, wrap=False,  # was=True
@@ -209,13 +213,14 @@ def intersections2(center1, radius1, center2, radius2, height=None, wrap=False,
                            equidistant=equidistant, tol=tol, LatLon=LatLon, **LatLon_kwds)
 
 
-def isclockwise(points, datum=_WGS84, wrap=True):
+def isclockwise(points, datum=_WGS84, wrap=True, polar=False):
     '''Determine the direction of a path or polygon.
 
        @arg points: The path or polygon points (C{LatLon}[]).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
+       @kwarg polar: Use C{B{polar}=True} if the C{B{points}} enclose a pole (C{bool}),
+                     see function U{ispolar<pygeodeys.points.ispolar>}.
 
        @return: C{True} if B{C{points}} are clockwise, C{False} otherwise.
 
@@ -223,12 +228,11 @@ def isclockwise(points, datum=_WGS84, wrap=True):
 
        @raise TypeError: Some B{C{points}} are not C{LatLon}.
 
-       @raise ValueError: The B{C{points}} enclose a pole or zero
-                          area.
+       @raise ValueError: The B{C{points}} enclose a pole or zero area.
 
        @see: L{pygeodesy.isclockwise}.
     '''
-    a = _polygon(datum.ellipsoid.geodsolve, points, True, False, wrap)
+    a = _polygon(datum.ellipsoid.geodsolve, points, True, False, wrap, polar)
     if a < 0:
         return True
     elif a > 0:
@@ -282,29 +286,25 @@ def nearestOn(point, point1, point2, within=True, height=None, wrap=False,
 def perimeterOf(points, closed=False, datum=_WGS84, wrap=True):
     '''Compute the perimeter of an (ellipsoidal) polygon or composite.
 
-       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or
-                    L{BooleanGH}).
+       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg closed: Optionally, close the polygon (C{bool}).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
 
-       @return: Perimeter (C{meter}, same as units of the B{C{datum}}'s
-                ellipsoid axes).
+       @return: Perimeter (C{meter}, same as units of the B{C{datum}}'s ellipsoid axes).
 
        @raise PointsError: Insufficient number of B{C{points}}.
 
        @raise TypeError: Some B{C{points}} are not L{LatLon}.
 
-       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled
-                          longitudes not supported or C{B{closed}=False}
-                          with C{B{points}} a composite.
+       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled longitudes not
+                          supported or C{B{closed}=False} with C{B{points}} a composite.
 
        @see: Functions L{pygeodesy.perimeterOf}, L{ellipsoidalExact.perimeterOf},
              L{ellipsoidalKarney.perimeterOf}, L{sphericalNvector.perimeterOf}
              and L{sphericalTrigonometry.perimeterOf}.
     '''
-    return _polygon(datum.ellipsoid.geodsolve, points, closed, True, wrap)
+    return _polygon(datum.ellipsoid.geodsolve, points, closed, True, wrap, False)
 
 
 __all__ += _ALL_OTHER(Cartesian, LatLon,  # classes

pygeodesy/ellipsoidalKarney.py

@@ -42,7 +42,7 @@ from pygeodesy.props import deprecated_method, Property_RO
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalKarney
-__version__ = '24.08.13'
+__version__ = '25.05.27'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -110,13 +110,17 @@ class LatLon(LatLonEllipsoidalBaseDI):
         return LatLonEllipsoidalBaseDI.toCartesian(self, **kwds)
 
 
-def areaOf(points, datum=_WGS84, wrap=True):
+def areaOf(points, datum=_WGS84, wrap=True, polar=False):
     '''Compute the area of an (ellipsoidal) polygon or composite using I{Karney}'s
        U{geographiclib<https://PyPI.org/project/geographiclib>} package.
 
        @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg datum: Optional datum (L{Datum}).
        @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
+       @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: Area (C{meter}, same as units of the B{C{datum}}'s ellipsoid axes, I{squared}).
 
@@ -131,12 +135,8 @@ def areaOf(points, datum=_WGS84, wrap=True):
 
        @see: Functions L{pygeodesy.areaOf}, L{ellipsoidalExact.areaOf}, L{ellipsoidalGeodSolve.areaOf},
              L{sphericalNvector.areaOf} and L{sphericalTrigonometry.areaOf}.
-
-       @note: The U{area of a polygon enclosing a pole<https://GeographicLib.SourceForge.io/
-              C++/doc/classGeographicLib_1_1GeodesicExact.html#a3d7a9155e838a09a48dc14d0c3fac525>}
-              can be found by adding half the datum's ellipsoid surface area to the polygon's area.
     '''
-    return fabs(_polygon(datum.ellipsoid.geodesic, points, True, False, wrap))
+    return fabs(_polygon(datum.ellipsoid.geodesic, points, True, False, wrap, polar))
 
 
 def intersection3(start1, end1, start2, end2, height=None, wrap=False,  # was=True
@@ -240,19 +240,19 @@ def intersections2(center1, radius1, center2, radius2, height=None, wrap=False,
                            equidistant=equidistant, tol=tol, LatLon=LatLon, **LatLon_kwds)
 
 
-def isclockwise(points, datum=_WGS84, wrap=True):
+def isclockwise(points, datum=_WGS84, wrap=True, polar=False):
     '''Determine the direction of a path or polygon using I{Karney}'s
        U{geographiclib<https://PyPI.org/project/geographiclib>} package.
 
        @arg points: The path or polygon points (C{LatLon}[]).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
+       @kwarg polar: Use C{B{polar}=True} if the C{B{points}} enclose a pole (C{bool}),
+                     see function U{ispolar<pygeodeys.points.ispolar>}.
 
        @return: C{True} if B{C{points}} are clockwise, C{False} otherwise.
 
-       @raise ImportError: Package U{geographiclib
-                           <https://PyPI.org/project/geographiclib>}
+       @raise ImportError: Package U{geographiclib<https://PyPI.org/project/geographiclib>}
                            not installed or not found.
 
        @raise PointsError: Insufficient number of B{C{points}}.
@@ -263,7 +263,7 @@ def isclockwise(points, datum=_WGS84, wrap=True):
 
        @see: L{pygeodesy.isclockwise}.
     '''
-    a = _polygon(datum.ellipsoid.geodesic, points, True, False, wrap)
+    a = _polygon(datum.ellipsoid.geodesic, points, True, False, wrap, polar)
     if a < 0:
         return True
     elif a > 0:
@@ -322,34 +322,29 @@ def perimeterOf(points, closed=False, datum=_WGS84, wrap=True):
     '''Compute the perimeter of an (ellipsoidal) polygon or composite using I{Karney}'s
        U{geographiclib<https://PyPI.org/project/geographiclib>} package.
 
-       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or
-                    L{BooleanGH}).
+       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg closed: Optionally, close the polygon (C{bool}).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
 
-       @return: Perimeter (C{meter}, same as units of the B{C{datum}}'s
-                ellipsoid axes).
+       @return: Perimeter (C{meter}, same as units of the B{C{datum}}'s ellipsoid axes).
 
-       @raise ImportError: Package U{geographiclib
-                           <https://PyPI.org/project/geographiclib>}
+       @raise ImportError: Package U{geographiclib<https://PyPI.org/project/geographiclib>}
                            not installed or not found.
 
        @raise PointsError: Insufficient number of B{C{points}}.
 
-       @raise TypeError: Some B{C{points}} are not L{LatLon} or C{B{closed}=False}
-                         with B{C{points}} a composite.
+       @raise TypeError: Some B{C{points}} are not L{LatLon} or C{B{closed}=False} with
+                         B{C{points}} a composite.
 
-       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled
-                          longitudes not supported or C{B{closed}=False}
-                          with C{B{points}} a composite.
+       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled longitudes not
+                          supported or C{B{closed}=False} with C{B{points}} a composite.
 
        @see: Functions L{pygeodesy.perimeterOf}, L{ellipsoidalExact.perimeterOf},
              L{ellipsoidalGeodSolve.perimeterOf}, L{sphericalNvector.perimeterOf}
              and L{sphericalTrigonometry.perimeterOf}.
     '''
-    return _polygon(datum.ellipsoid.geodesic, points, closed, True, wrap)
+    return _polygon(datum.ellipsoid.geodesic, points, closed, True, wrap, False)
 
 
 __all__ += _ALL_OTHER(Cartesian, LatLon,  # classes

pygeodesy/ellipsoidalVincenty.py

@@ -76,7 +76,7 @@ from pygeodesy.utily import atan2, atan2b, atan2d, sincos2, sincos2d, \
 from math import cos, degrees, fabs, radians, tan as _tan
 
 __all__ = _ALL_LAZY.ellipsoidalVincenty
-__version__ = '25.05.23'
+__version__ = '25.05.26'
 
 _antipodal_to_ = _SPACE_(_antipodal_, _to_)
 
@@ -349,13 +349,6 @@ def _c2sm2(c2sm):
     return c2sm**2 * _2_0 - _1_0
 
 
-def _ellipsoidal():  # helper for areaOf and perimeterOf
-    try:
-        return _MODS.ellipsoidalKarney
-    except ImportError:
-        return _MODS.ellipsoidalExact
-
-
 def _Dl(f, ca2, sa, s, cs, ss, c2sm, dl=_0_0):
     # C{Dl}
     if f and sa:
@@ -385,6 +378,14 @@ def _Ecef():
     return E
 
 
+def _ellipsoidalOf(_Of, points, **kwds):  # helper for DEPRECATED areaOf and perimeterOf
+    try:
+        r = getattr(_MODS.ellipsoidalKarney, _Of.__name__)(points, **kwds)
+    except ImportError:  # no geographiclib
+        r = getattr(_MODS.ellipsoidalExact, _Of.__name__)(points, **kwds)
+    return r
+
+
 def _sincos22(sa):
     # 2-Tuple C{(sin(a), cos(a)**2)}
     ca2 = _1_0 - sa**2
@@ -403,10 +404,10 @@ def _sincostan3r(a, f):
 
 
 @deprecated_function
-def areaOf(points, **datum_wrap):
+def areaOf(points, **datum_wrap_polar):
     '''DEPRECATED, use function L{ellipsoidalExact.areaOf} or L{ellipsoidalKarney.areaOf}.
     '''
-    return _ellipsoidal().areaOf(points, **datum_wrap)
+    return _ellipsoidalOf(areaOf, points, **datum_wrap_polar)
 
 
 def intersection3(start1, end1, start2, end2, height=None, wrap=False,  # was=True
@@ -562,7 +563,7 @@ def nearestOn(point, point1, point2, within=True, height=None, wrap=False,
 def perimeterOf(points, **closed_datum_wrap):
     '''DEPRECATED, use function L{ellipsoidalExact.perimeterOf} or L{ellipsoidalKarney.perimeterOf}.
     '''
-    return _ellipsoidal().perimeterOf(points, **closed_datum_wrap)
+    return _ellipsoidalOf(perimeterOf, points, **closed_datum_wrap)
 
 
 __all__ += _ALL_DOCS(Cartesian, LatLon, intersecant2,  # from .ellipsoidalBaseDI

pygeodesy/elliptic.py

@@ -99,7 +99,7 @@ from math import asin, asinh, atan, ceil, cosh, fabs, floor, radians, \
                  sin, sinh, sqrt, tan, tanh  # tan as _tan
 
 __all__ = _ALL_LAZY.elliptic
-__version__ = '25.05.12'
+__version__ = '25.05.28'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
@@ -165,9 +165,9 @@ class Elliptic(_Named):
                   that case, we have C{Π(φ, 0, k) = F(φ, k), G(φ, 0, k) =
                   E(φ, k)} and C{H(φ, 0, k) = F(φ, k) - D(φ, k)}.
         '''
-        self.reset(k2=k2, alpha2=alpha2, kp2=kp2, alphap2=alphap2)
         if name:
             self.name = name
+        self.reset(k2=k2, alpha2=alpha2, kp2=kp2, alphap2=alphap2)
 
     @Property_RO
     def alpha2(self):
@@ -760,15 +760,20 @@ class Elliptic(_Named):
                   that these conditions are met to enable accuracy to be
                   maintained, e.g., when C{k} is very close to unity.
         '''
+        def _1p2(kp2, k2):
+            return (_1_0 - k2) if kp2 is None else kp2
+
+        def _S(**kwds):
+            return Scalar_(Error=EllipticError, **kwds)
+
         if self.__dict__:
             _update_all(self, _Named.iteration._uname, Base=Property_RO)
 
-        self._k2  = Scalar_(k2=k2, Error=EllipticError, low=None, high=_1_0)
-        self._kp2 = Scalar_(kp2=((_1_0 - k2) if kp2 is None else kp2), Error=EllipticError)
+        self._k2      = _S(k2 = k2, low=None, high=_1_0)
+        self._kp2     = _S(kp2=_1p2(kp2, k2))  # low=_0_0
 
-        self._alpha2  = Scalar_(alpha2=alpha2, Error=EllipticError, low=None, high=_1_0)
-        self._alphap2 = Scalar_(alphap2=((_1_0 - alpha2) if alphap2 is None else alphap2),
-                                Error=EllipticError)
+        self._alpha2  = _S(alpha2 = alpha2, low=None, high=_1_0)
+        self._alphap2 = _S(alphap2=_1p2(alphap2, alpha2))  # low=_0_0
 
         # Values of complete elliptic integrals for k = 0,1 and alpha = 0,1
         #         K     E     D
@@ -1120,11 +1125,11 @@ def _rC(unused, x, y):
     '''(INTERNAL) Defined only for C{y != 0} and C{x >= 0}.
     '''
     d = x - y
-    if d < 0:  # catch NaN
+    if x < y:  # catch NaN
         # <https://DLMF.NIST.gov/19.2.E18>
-        d = -d
+        d = y - x
         r = atan(sqrt(d / x)) if x > 0 else PI_2
-    elif d == 0:  # XXX d < EPS0? or EPS02 or _EPSmin
+    elif x == y:  # XXX d < EPS0? or EPS02 or _EPSmin
         d, r = y, _1_0
     elif y > 0:  # <https://DLMF.NIST.gov/19.2.E19>
         r = asinh(sqrt(d / y))  # atanh(sqrt((x - y) / x))

pygeodesy/frechet.py

@@ -101,7 +101,7 @@ from collections import defaultdict as _defaultdict
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.frechet
-__version__ = '25.05.21'
+__version__ = '25.05.26'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -153,7 +153,7 @@ class Frechet(_Named):
            @raise FrechetError: Insufficient number of B{C{point1s}} or an invalid
                                 B{C{point1}}, B{C{fraction}} 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