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

pygeodesy/__init__.py

@@ -8,8 +8,8 @@ geodetic (lat-/longitude), geocentric (U{ECEF<https://WikiPedia.org/wiki/ECEF>}
 <https://GeographicLib.SourceForge.io/1.44/triaxial.html>} coordinates.
 
 Transcoded in part from U{JavaScript originals<https://GitHub.com/ChrisVeness/geodesy>} by I{Chris Veness (C)
-2005-2024} and from several U{C++ classes<https://GeographicLib.SourceForge.io/C++/doc/annotated.html>} by I{Charles
-F. F. Karney (C) 2008-2024} and published under the same U{MIT License<https://OpenSource.org/licenses/MIT>}**.
+2005-2025} and from several U{C++ classes<https://GeographicLib.SourceForge.io/C++/doc/annotated.html>} by I{Charles
+F. F. Karney (C) 2008-2025} and published under the same U{MIT License<https://OpenSource.org/licenses/MIT>}**.
 
 There are four modules for ellipsoidal earth models, C{ellipsoidalExact}, C{-Karney}, C{-Vincenty} and C{-Nvector}
 and two for spherical ones, C{sphericalTrigonometry} and C{-Nvector}.  Each module provides a geodetic B{C{LatLon}}
@@ -101,9 +101,15 @@ and L{GnomonicGeodSolve} depend on I{Karney}'s C++ utility U{GeodSolve
 <https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>} to be executable and set with
 env variable C{PYGEODESY_GEODSOLVE} or with property L{Ellipsoid.geodsolve}.
 
+Triaxial geodesic classes L{Geodesic3Solve} and L{GeodesicLine3Solve} in module L{geod3solve} need
+I{Karney}'s C++ utility U{Geod3Solve<https://GeographicLib.SourceForge.io/C++/doc/Geod3Solve.1.html>}
+to be executable and set with env variable C{PYGEODESY_GEOD3SOLVE} or with property
+L{Geodesic3Solve.Geod3Solve<geod3solve._Geodesic3SolveBase.Geod3Solve>}.
+
 Class L{Intersectool} in module L{geodesici} needs I{Karney}'s C++ utility U{IntersectTool
 <https://GeographicLib.SourceForge.io/C++/doc/IntersectTool.1.html>} to be executable and set with
-env variable C{PYGEODESY_INTERSECTTOOL}.
+env variable C{PYGEODESY_INTERSECTTOOL} or with property L{Intersectool.IntersectTool
+<geodesici.Intersectool.IntersectTool>}.
 
 To compare C{MGRS} results from modules L{mgrs} and C{testMgrs} with I{Karney}'s C++ utility
 U{GeoConvert<https://GeographicLib.SourceForge.io/C++/doc/GeoConvert.1.html>}, the latter must
@@ -128,22 +134,24 @@ Tests
 The tests ran with Python 3.14.2 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.1),
 Python 3.13.9 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.1),
 U{numpy<https://PyPI.org/project/numpy>} 2.3.3, U{scipy<https://PyPI.org/project/scipy>} 1.16.2,
-U{GeoConvert<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5 and
-U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5),
+U{GeoConvert<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7 and
+U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7),
 Python 3.12.7 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0,
 U{numpy<https://PyPI.org/project/numpy>} 2.1.0, U{scipy<https://PyPI.org/project/scipy>} 1.14.1,
-U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5,
-U{IntersectTool<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5 and
-U{RhumbSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5),
+U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7,
+U{GeodS3olve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7,
+U{IntersectTool<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7 and
+U{RhumbSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7),
 Python 3.11.5 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0,
 U{numpy<https://PyPI.org/project/numpy>} 1.24.2 and U{scipy<https://PyPI.org/project/scipy>} 1.10.1),
 and with Python 2.7.18 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 1.50,
 U{numpy<https://PyPI.org/project/numpy>} 1.16.6, U{scipy<https://PyPI.org/project/scipy>} 1.2.2,
-U{GeoConvert<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5,
-U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5,
-U{IntersectTool<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5 and
-U{RhumbSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5), all in 64-bit on
-macOS 26.1 Tahoe.
+U{GeoConvert<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7,
+U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7,
+U{Geod3Solve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7,
+U{IntersectTool<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7 and
+U{RhumbSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.7), all in 64-bit on
+macOS 26.2 Tahoe.
 
 All tests ran with and without C{lazy import} for Python 3 and with command line option C{-W default} and
 env variable C{PYGEODESY_WARNINGS=on} for all Python versions.  The results of those tests are included in
@@ -153,11 +161,11 @@ Test coverage has been measured with U{coverage<https://PyPI.org/project/coverag
 3.14.2, 3.13.9 and 3.12.7.  The complete coverage report in HTML and a PDF summary are included in the
 distribution files.
 
-Python 3.14.2, 3.13.9, 3.12.7 and 3.11.5 run on Apple M4 Si (C{arm64}), I{natively}.  Python 2.7.18 runs
+Python 3.14.2, 3.13.9, 3.12.7 and 3.11.5 run on Apple Si M4 (C{arm64}), I{natively}.  Python 2.7.18 runs
 on Intel (C{x86_64}) or Intel I{emulation} ("C{arm64_x86_64}", see function L{machine<pygeodesy.machine>}).
 
-The tests also ran with Python 3.13.9 (and U{geographiclib<https://PyPI.org/project/geographiclib>} 2.1) on
-U{Debian 12<https://Cirrus-CI.com/github/mrJean1/PyGeodesy/master>} in 64-bit only, with Python 3.12.8 (and
+The tests also ran with Python 3.14.2 (and U{geographiclib<https://PyPI.org/project/geographiclib>} 2.1) on
+U{Debian 12<https://Cirrus-CI.com/github/mrJean1/PyGeodesy/master>} in 64-bit only, with Python 3.13.9 (and
 U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0) on U{Windows 2019Server
 <https://CI.AppVeyor.com/project/mrJean1/pygeodesy>} in 64-bit only and with Python 2.7.18 (and U{geographiclib
 <https://PyPI.org/project/geographiclib>} 1.52) on U{Windows 10<https://CI.AppVeyor.com/project/mrJean1/pygeodesy>}
@@ -190,7 +198,7 @@ All Python source code has been statically U{checked<https://GitHub.com/ActiveSt
 546532_PyChecker_postprocessor>} with U{Ruff<https://GitHub.com/astral-sh/ruff>} using Python 3.13.9 and with
 U{PyChecker<https://PyPI.org/project/pychecker>}, U{PyFlakes<https://PyPI.org/project/pyflakes>}, U{PyCodeStyle
 <https://PyPI.org/project/pycodestyle>} (formerly Pep8) and U{McCabe<https://PyPI.org/project/mccabe>} using Python
-2.7.18, both in 64-bit on macOS 26.1 Tahoe.
+2.7.18, both in 64-bit on macOS 26.2 Tahoe.
 
 For a summary of all I{Karney}-based functionality in C{pygeodesy}, see module U{karney
 <https://mrJean1.GitHub.io/PyGeodesy/docs/pygeodesy.karney-module.html>}.
@@ -210,7 +218,7 @@ The following environment variables are observed by C{pygeodesy}:
  - C{PYGEODESY_FSUM_RESIDUAL} - see module L{fsums<pygeodesy.fsums>} and method L{RESIDUAL<pygeodesy.Fsum.RESIDUAL>}.
  - C{PYGEODESY_GEOCONVERT} - see module L{mgrs<pygeodesy.mgrs>}.
  - C{PYGEODESY_GEODSOLVE} - see module L{geodsolve<pygeodesy.geodsolve>}.
- - C{PYGEODESY_GEOD3SOLVE} - see module L{geodsolve<pygeodesy.geod3solve>}.
+ - C{PYGEODESY_GEOD3SOLVE} - see module L{geod3solve<pygeodesy.geod3solve>}.
  - C{PYGEODESY_INTERSECTTOOL} - see module L{geodesici<pygeodesy.geodesici>}.
  - C{PYGEODESY_LAZY_IMPORT} - see module L{lazily<pygeodesy.lazily>} and variable L{isLazy<pygeodesy.isLazy>}.
  - C{PYGEODESY_NOTIMPLEMENTED} - C{__special__} methods return C{NotImplemented} if set to "std".
@@ -618,7 +626,7 @@ else:
 
 from pygeodesy.internals import _version2,  _DOT_  # noqa: E402
 # from pygeodesy.interns import _DOT_  # from .internals
-__version__ = '25.12.12'
+__version__ = '25.12.31'
 # see setup.py for similar logic
 version     = _DOT_(*_version2(__version__, n=3))
 

pygeodesy/constants.py

@@ -332,6 +332,8 @@ R_VM  = _Radius(R_VM=6366707.0194937)  # PYCHOK aViation/naVigation earth radius
 
 _INF_NAN_NINF = {INF, NAN, NINF, _inf, _nan}
 _pos_self     = _1_0.__pos__() is _1_0  # PYCHOK in .fsums, .vector3dBase
+_1_3rd        =  1 / 3  # in .fmath
+_2_3rd        =  2 / 3  # in .fmath, .formy
 
 
 def _0_0s(n):

pygeodesy/ellipsoids.py

@@ -67,10 +67,10 @@ from __future__ import division as _; del _  # noqa: E702 ;
 # from pygeodesy.albers import AlbersEqualAreaCylindrical  # _MODS
 from pygeodesy.basics import copysign0, isbool, _isin, isint,  typename
 from pygeodesy.constants import EPS, EPS_2, EPS0, EPS02, EPS1, INF, NINF, \
-                               _over, PI_2, PI_3, PI4, R_M, R_MA, R_FM, _EPSqrt, \
+                               _EPSqrt, PI_2, PI_3, PI2, PI4, R_M, R_MA, R_FM, \
                                _EPStol as _TOL, _floatuple as _T, _isfinite, \
-                               _0_0s, _0_0, _0_5, _1_0, _1_EPS, _2_0, _4_0, _90_0, \
-                               _0_25, _3_0  # PYCHOK used!
+                               _over, _0_0s, _0_0, _0_5, _1_0, _1_EPS, _2_0, \
+                               _4_0, _90_0, _0_25, _3_0  # PYCHOK used!
 from pygeodesy.errors import _AssertionError, IntersectionError, _ValueError, _xattr, _xkwds_not
 from pygeodesy.fmath import cbrt, cbrt2, fdot, Fhorner, fpowers, hypot, hypot_, \
                             hypot1, hypot2, sqrt3,  Fsum
@@ -96,7 +96,7 @@ from pygeodesy.utily import atan1, atan1d, atan2b, degrees90, m2radians, radians
 from math import asinh, atan, atanh, cos, degrees, exp, fabs, radians, sin, sinh, sqrt, tan  # as _tan
 
 __all__ = _ALL_LAZY.ellipsoids
-__version__ = '25.11.26'
+__version__ = '25.12.14'
 
 _f_0_0    = Float(f =_0_0)  # zero flattening
 _f__0_0   = Float(f_=_0_0)  # zero inverse flattening
@@ -111,19 +111,19 @@ def _aux(lat, inverse, auxLat, clip=90):
     return Lat(lat, clip=clip, name=_lat_ if inverse else typename(auxLat))
 
 
-def _s2_c2(phi):
+def _sin2cos2(rad):
     '''(INTERNAL) Return 2-tuple C{(sin(B{phi})**2, cos(B{phi})**2)}.
     '''
-    if phi:
-        s2 = sin(phi)**2
+    if rad:
+        s2 = sin(rad)**2
         if s2 > EPS:
             c2 = _1_0 - s2
             if c2 > EPS:
                 if c2 < EPS1:
                     return s2, c2
             else:
-                return _1_0, _0_0  # phi == PI_2
-    return _0_0, _1_0  # phi == 0
+                return _1_0, _0_0  # rad == PI_2
+    return _0_0, _1_0  # rad == 0
 
 
 class a_f2Tuple(_NamedTuple):
@@ -871,6 +871,12 @@ class Ellipsoid(_NamedEnumItem):
 
     equatoradius = a  # Requatorial
 
+    @Property_RO
+    def equatorimeter(self):
+        '''Get the ellipsoid's I{equatorial} perimeter (C{meter}).
+        '''
+        return Meter(equatorimeter=self.a * PI2)
+
     def e2s(self, s):
         '''Compute norm M{sqrt(1 - e2 * s**2)}.
 
@@ -1381,6 +1387,12 @@ class Ellipsoid(_NamedEnumItem):
 
     polaradius = b  # Rpolar
 
+    @property_RO
+    def polarimeter(self):
+        '''Get the ellipsoid's I{polar}, meridional perimeter (C{meter}).
+        '''
+        return Meter(polarimeter=self.L * _4_0)
+
 #   Q = A  # I{meridian arc unit} C{Q}, the mean, meridional length I{per radian}
 
     @deprecated_Property_RO
@@ -1484,7 +1496,7 @@ class Ellipsoid(_NamedEnumItem):
         r, p = self.a, Phid(lat)
         if p and self.f:
             if fabs(p) < PI_2:
-                s2, c2 = _s2_c2(p)
+                s2, c2 = _sin2cos2(p)
                 # R == sqrt((a2**2 * c2 + b2**2 * s2) / (a2 * c2 + b2 * s2))
                 #   == sqrt(a2**2 * (c2 + (b2 / a2)**2 * s2) / (a2 * (c2 + b2 / a2 * s2)))
                 #   == sqrt(a2 * (c2 + (b2 / a2)**2 * s2) / (c2 + (b2 / a2) * s2))
@@ -1709,7 +1721,7 @@ class Ellipsoid(_NamedEnumItem):
         '''(INTERNAL) Helper for C{rocAzimuth} and C{rocBearing}.
         '''
         if self.f:
-            s2, c2 = _s2_c2(radians(deg))
+            s2, c2 = _sin2cos2(radians(deg))
             m, n = self.roc2_(Phid(lat))
             if n < m:  # == n / (c2 * n / m + s2)
                 c2 *= n / m
@@ -1751,7 +1763,7 @@ class Ellipsoid(_NamedEnumItem):
         # ... requires 1 or 2 sqrt
         g = self.b
         if self.f:
-            s2, c2 = _s2_c2(Phid(lat))
+            s2, c2 = _sin2cos2(Phid(lat))
             g = _over(g, c2 + self.b2_a2 * s2)
         return Radius(rocGauss=g)
 

pygeodesy/fmath.py

@@ -10,8 +10,8 @@ from __future__ import division as _; del _  # noqa: E702 ;
 from pygeodesy.basics import _copysign, copysign0, isbool, isint, isodd, \
                               isscalar, len2, map1, _xiterable,  typename
 from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
-                               _0_0, _0_125, _0_25, _0_5, _1_0, _1_5, \
-                               _copysign_0_0, isfinite, remainder
+                               _0_0, _0_125, _0_25, _1_3rd, _0_5, _2_3rd, \
+                               _1_0, _1_5, _copysign_0_0, isfinite, remainder
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
                              _xError, _xkwds, _xkwds_pop2, _xsError
 from pygeodesy.fsums import _2float, Fsum, fsum, _isFsum_2Tuple,  Fmt, unstr
@@ -25,13 +25,11 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '25.12.02'
+__version__ = '25.12.23'
 
 # sqrt(2) - 1 <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ~ 3_730_904_090_310_553 / 9_007_199_254_740_992
-_1_3rd   = _1_0 / 3
-_1_6th   = _1_0 / 6
-_2_3rd   = _1_3rd * 2
+_1_6th   =  1 / 6
 _h_lt_b_ = 'abs(h) < abs(b)'
 
 
@@ -1049,7 +1047,7 @@ def sqrt3(x):
 
 
 def sqrt_a(h, b):
-    '''Compute C{I{a}} side of a right-angled triangle from
+    '''Compute the C{I{a}} side of a right-angled triangle from
        C{sqrt(B{h}**2 - B{b}**2)}.
 
        @arg h: Hypotenuse or outer annulus radius (C{scalar}).

pygeodesy/formy.py

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