pygeodesy 25.8.25__py2.py3-none-any.whl → 25.10.10__py2.py3-none-any.whl

pygeodesy/ellipsoids.py

@@ -67,8 +67,8 @@ 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, _EPStol as _TOL, _floatuple as _T, _isfinite, \
+                               _over, PI_2, PI_3, PI4, R_M, R_MA, R_FM, _EPSqrt, \
+                               _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!
 from pygeodesy.errors import _AssertionError, IntersectionError, _ValueError, _xattr, _xkwds_not
@@ -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.08.25'
+__version__ = '25.08.31'
 
 _f_0_0    = Float(f =_0_0)  # zero flattening
 _f__0_0   = Float(f_=_0_0)  # zero inverse flattening
@@ -443,7 +443,7 @@ class Ellipsoid(_NamedEnumItem):
                                 eps=eps, f0=f0, **name_value))
 
     def auxAuthalic(self, lat, inverse=False):
-        '''Compute the I{authalic} auxiliary latitude or the I{inverse} thereof.
+        '''Compute the I{authalic} auxiliary latitude (Xi) or the I{inverse} thereof.
 
            @arg lat: The geodetic (or I{authalic}) latitude (C{degrees90}).
            @kwarg inverse: If C{True}, B{C{lat}} is the I{authalic} and
@@ -463,7 +463,7 @@ class Ellipsoid(_NamedEnumItem):
         return _aux(lat, inverse, Ellipsoid.auxAuthalic)
 
     def auxConformal(self, lat, inverse=False):
-        '''Compute the I{conformal} auxiliary latitude or the I{inverse} thereof.
+        '''Compute the I{conformal} auxiliary latitude (Chi) or the I{inverse} thereof.
 
            @arg lat: The geodetic (or I{conformal}) latitude (C{degrees90}).
            @kwarg inverse: If C{True}, B{C{lat}} is the I{conformal} and
@@ -481,12 +481,13 @@ class Ellipsoid(_NamedEnumItem):
             lat = atan1d(f(tan(Phid(lat))))  # PYCHOK attr
         return _aux(lat, inverse, Ellipsoid.auxConformal)
 
-    def auxGeocentric(self, lat, inverse=False):
-        '''Compute the I{geocentric} auxiliary latitude or the I{inverse} thereof.
+    def auxGeocentric(self, lat, inverse=False, height=_0_0):
+        '''Compute the I{geocentric} auxiliary latitude (Theta) or the I{inverse} thereof.
 
            @arg lat: The geodetic (or I{geocentric}) latitude (C{degrees90}).
            @kwarg inverse: If C{True}, B{C{lat}} is the geocentric and
                            return the I{geocentric} latitude (C{bool}).
+           @kwarg height: Optional, ellipsoidal height (C{meter}).
 
            @return: The I{geocentric} (or geodetic) latitude in C{degrees90}.
 
@@ -495,13 +496,24 @@ class Ellipsoid(_NamedEnumItem):
                  <https://WikiPedia.org/wiki/Latitude#Geocentric_latitude>}, and
                  U{Snyder<https://Pubs.USGS.gov/pp/1395/report.pdf>}, pp 17-18.
         '''
-        if self.f:
-            f   = self.a2_b2 if inverse else self.b2_a2
-            lat = atan1d(tan(Phid(lat)) * f)
+        if self.f:  # and lat
+            t = tan(Phid(lat))
+            f = self.b2_a2
+            if height:
+                if inverse:
+                    lat = atan1d(t * f)  # geodetic n
+                    d, f = f, _1_0
+                else:
+                    d = _1_0
+                n =  self.rocPrimeVertical(lat)
+                f = _over(n * f + height, n * d + height)
+            elif inverse:
+                f = self.a2_b2
+            lat = atan1d(t * f)
         return _aux(lat, inverse, Ellipsoid.auxGeocentric)
 
     def auxIsometric(self, lat, inverse=False):
-        '''Compute the I{isometric} auxiliary latitude or the I{inverse} thereof.
+        '''Compute the I{isometric} auxiliary latitude (Psi) or the I{inverse} thereof.
 
            @arg lat: The geodetic (or I{isometric}) latitude (C{degrees}).
            @kwarg inverse: If C{True}, B{C{lat}} is the I{isometric} and
@@ -510,8 +522,8 @@ class Ellipsoid(_NamedEnumItem):
            @return: The I{isometric} (or geodetic) latitude in C{degrees}.
 
            @note: The I{isometric} latitude for geodetic C{+/-90} is far
-                  outside the C{[-90..+90]} range but the inverse
-                  thereof is the original geodetic latitude.
+                  outside the C{[-90..+90]} range but the inverse thereof
+                  is the original geodetic latitude.
 
            @see: U{Inverse-/IsometricLatitude<https://GeographicLib.SourceForge.io/
                  C++/doc/classGeographicLib_1_1Ellipsoid.html>}, U{Isometric latitude
@@ -526,7 +538,7 @@ class Ellipsoid(_NamedEnumItem):
         return _aux(lat, inverse, Ellipsoid.auxIsometric, clip=0)
 
     def auxParametric(self, lat, inverse=False):
-        '''Compute the I{parametric} auxiliary latitude or the I{inverse} thereof.
+        '''Compute the I{parametric} auxiliary latitude (Beta) or the I{inverse} thereof.
 
            @arg lat: The geodetic (or I{parametric}) latitude (C{degrees90}).
            @kwarg inverse: If C{True}, B{C{lat}} is the I{parametric} and
@@ -546,7 +558,7 @@ class Ellipsoid(_NamedEnumItem):
     auxReduced = auxParametric  # synonymous
 
     def auxRectifying(self, lat, inverse=False):
-        '''Compute the I{rectifying} auxiliary latitude or the I{inverse} thereof.
+        '''Compute the I{rectifying} auxiliary latitude (Mu) or the I{inverse} thereof.
 
            @arg lat: The geodetic (or I{rectifying}) latitude (C{degrees90}).
            @kwarg inverse: If C{True}, B{C{lat}} is the I{rectifying} and
@@ -692,23 +704,23 @@ class Ellipsoid(_NamedEnumItem):
         '''
         lat = Lat(lat)
         if lat:
-            b = lat
+            B = lat  # beta
             if fabs(lat) < _90_0:
                 if self.f:
-                    b = self._beta(lat)
-                z, r = sincos2d(b)
+                    B = self._beta(lat)
+                z, r = sincos2d(B)
                 r *= self.a
                 z *= self.b
             else:  # near-polar
                 r, z = _0_0, copysign0(self.b, lat)
         else:  # equator
             r = self.a
-            z = lat = b = _0_0
-        return Circle4Tuple(r, z, lat, b)
+            z = lat = B = _0_0
+        return Circle4Tuple(r, z, lat, B)
 
     def degrees2m(self, deg, lat=0):
-        '''Convert an angle to the distance along the equator or
-           along a parallel of (geodetic) latitude.
+        '''Convert an angle along the equator or along a parallel
+           of (geodetic) latitude to the distance.
 
            @arg deg: The angle (C{degrees}).
            @kwarg lat: Parallel latitude (C{degrees90}, C{str}).
@@ -878,10 +890,10 @@ class Ellipsoid(_NamedEnumItem):
 
            @raise ValueError: Invalid B{C{s}}.
         '''
-        r = _1_0
-        if self.e2:
+        r, e2 = _1_0, self.e2
+        if e2:  # and s
             try:
-                r -= self.e2 * Scalar(s=s)**2
+                r -= e2 * Scalar(s=s)**2
                 if r < 0:
                     raise ValueError(_negative_)
             except (TypeError, ValueError) as x:
@@ -1468,19 +1480,18 @@ class Ellipsoid(_NamedEnumItem):
            @see: U{Geocentric Radius
                  <https://WikiPedia.org/wiki/Earth_radius#Geocentric_radius>}
         '''
-        r, a = self.a, Phid(lat)
-        if a and self.f:
-            if fabs(a) < PI_2:
-                s2, c2 = _s2_c2(a)
-                b2_a2_s2 = self.b2_a2 * s2
+        r, p = self.a, Phid(lat)
+        if p and self.f:
+            if fabs(p) < PI_2:
+                s2, c2 = _s2_c2(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))
                 #   == a * sqrt((c2 + b2_a2 * b2_a2 * s2) / (c2 + b2_a2 * s2))
-                #   == a * sqrt((c2 + b2_a2 * b2_a2_s2) / (c2 + b2_a2_s2))
-                r *= sqrt((c2 + b2_a2_s2 * self.b2_a2) / (c2 + b2_a2_s2))
+                s2 *= self.b2_a2
+                r  *= sqrt((c2 + self.b2_a2 * s2) / (c2 + s2))
             else:
-                r  = self.b
+                r = self.b
         return Radius(Rgeocentric=r)
 
     @Property_RO
@@ -1653,18 +1664,18 @@ class Ellipsoid(_NamedEnumItem):
                  and the meridional and prime vertical U{Radii of Curvature
                  <https://WikiPedia.org/wiki/Earth_radius#Radii_of_curvature>}.
         '''
-        a = fabs(Phi(phi))
+        p = fabs(Phi(phi))
         if self.f:
-            r = self.e2s2(sin(a))
+            r = self.e2s2(sin(p))
             if r > EPS02:
-                n = self.a / sqrt(r)
-                m = n *  self.e21 / r
+                n = sqrt(self.a2 / r)
+                m = n * self.e21 / r
             else:
                 m = n = _0_0
         else:
             m = n = self.a
-        if scaled and a:
-            n *= cos(a) if a < PI_2 else _0_0
+        if scaled and p:
+            n *= cos(p) if p < PI_2 else _0_0
         return Curvature2Tuple(m, n)
 
     def rocAzimuth(self, lat, azimuth):
@@ -1795,8 +1806,8 @@ class Ellipsoid(_NamedEnumItem):
                  U{Radii of Curvature<https://WikiPedia.org/wiki/
                  Earth_radius#Radii_of_curvature>}.
         '''
-        r = self.roc2_(Phid(lat)) if lat else self.rocEquatorial2
-        return Radius(rocPrimeVertical=r.prime_vertical)
+        r = self.roc1_(sin(Phid(lat))) if lat else self.a
+        return Radius(rocPrimeVertical=r)
 
     rocTransverse = rocPrimeVertical  # synonymous
 

pygeodesy/elliptic.py

@@ -75,7 +75,7 @@ U{22<https://DLMF.NIST.gov/22>}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # noqa: E702 ;
 
-from pygeodesy.basics import copysign0, map2, neg, neg_,  typename
+from pygeodesy.basics import copysign0, map2, neg, neg_
 from pygeodesy.constants import EPS, INF, NAN, PI, PI_2, PI_4, \
                                _EPStol as _TolJAC, _0_0, _0_25, \
                                _0_5, _1_0, _2_0, _N_2_0, _3_0, \
@@ -85,7 +85,7 @@ from pygeodesy.constants import _EPSjam as _TolJAM  # PYCHOK used!
 # from pygeodesy.errors import _ValueError  # from .fsums
 from pygeodesy.fmath import favg, Fdot_, fma, hypot1, zqrt
 from pygeodesy.fsums import Fsum, _fsum,  _ValueError
-# from pygeodesy.internals import typename  # from .basics
+from pygeodesy.internals import _Enum, typename
 from pygeodesy.interns import NN, _delta_, _DOT_, _f_, _invalid_, \
                              _invokation_, _negative_, _SPACE_
 from pygeodesy.karney import _K_2_0, _norm180, _signBit, _sincos2
@@ -100,7 +100,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.06.02'
+__version__ = '25.10.10'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
@@ -108,13 +108,10 @@ _TolRG0 = _TolJAC   * 2.7
 _TRIPS  =  28  # Max depth, 6-18 might be sufficient
 
 
-class _Cs(object):
-    '''(INTERAL) Complete integrals cache.
+class _Cs(_Enum):
+    '''(INTERAL) Complete Integrals cache.
     '''
-    def __init__(self, **kwds):
-        # for n,v in kwds.items():
-        #     setattr(self, n, v)
-        self.__dict__ = kwds
+    pass
 
 
 class Elliptic(_Named):
@@ -773,8 +770,8 @@ class Elliptic(_Named):
         def _S(**kwds):
             return Scalar_(Error=EllipticError, **kwds)
 
-        self._k2      = _S(k2 = k2, low=None, high=_1_0)
-        self._kp2     = _S(kp2=_1p2(kp2, k2))  # low=_0_0
+        self._k2  = _S(k2 = k2, low=None, high=_1_0)
+        self._kp2 = _S(kp2=_1p2(kp2, k2))  # low=_0_0
 
         self._alpha2  = _S(alpha2 = alpha2, low=None, high=_1_0)
         self._alphap2 = _S(alphap2=_1p2(alphap2, alpha2))  # low=_0_0
@@ -935,7 +932,7 @@ class Elliptic(_Named):
             raise _ellipticError(Elliptic._RFRD, x, y, z, m, cause=X)
         return float(R)
 
-_allPropertiesOf_n(16, Elliptic)  #  # PYCHOK assert, see Elliptic.reset
+_allPropertiesOf_n(16, Elliptic)  # PYCHOK assert, see Elliptic.reset
 
 
 class EllipticError(_ValueError):

pygeodesy/errors.py

@@ -16,9 +16,10 @@ C{PYGEODESY_EXCEPTION_CHAINING=std} or to any non-empty string.
 # from pygeodesy import errors  # _MODS, _MODS.getattr
 from pygeodesy.internals import _envPYGEODESY, _plural, _tailof, typename
 from pygeodesy.interns import MISSING, NN, _a_, _an_, _and_, _clip_, _COLON_, _COLONSPACE_, \
-                             _COMMASPACE_, _datum_, _ELLIPSIS_, _ellipsoidal_, _incompatible_, \
-                             _invalid_, _keyword_, _LatLon_, _len_, _not_, _or_, _SPACE_, \
-                             _specified_, _UNDER_, _vs_, _with_
+                             _COMMASPACE_, _datum_, _DOT_, _ELLIPSIS_, _ellipsoidal_, \
+                             _EQUALSPACED_, _immutable_, _incompatible_, _invalid_, _keyword_, \
+                             _LatLon_, _len_, _not_, _or_, _SPACE_, _specified_, _UNDER_, \
+                             _vs_, _with_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYTHON_X_DEV
 # from pygeodesy import streprs as _streprs  # _MODS.into
 # from pygeodesy.unitsBase import Str  # _MODS
@@ -27,11 +28,12 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYTHON_X_DEV
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '25.05.19'
+__version__ = '25.09.04'
 
 _argument_   = 'argument'
 _basics      = _MODS.into(basics=__name__)
 _box_        = 'box'
+_del_        = 'del'
 _expected_   = 'expected'
 _limiterrors =  True  # in .formy
 _name_value_ =  repr('name=value')
@@ -224,7 +226,8 @@ class IntersectionError(_ValueError):  # in .ellipsoidalBaseDI, .formy, ...
         '''New L{IntersectionError}.
         '''
         if args:
-            _ValueError.__init__(self, _SPACE_(*args), **kwds)
+            t = _COMMASPACE_(*map(repr, args))
+            _ValueError.__init__(self, t, **kwds)
         else:
             _ValueError.__init__(self, **kwds)
 
@@ -474,6 +477,16 @@ def exception_chaining(exc=None):
             getattr(exc, '__cause__', None)  # _DCAUSE_
 
 
+def _ImmutableError(inst, attr, value=_del_, Error=_TypeError):  # PYCHOK self
+    '''(INTERNAL) Format an C{immutable _TypeError}.
+    '''
+    n =  typename(inst)
+    n = _DOT_(_xattr(inst, name=n), attr)
+    t = _SPACE_(_del_, n) if value is _del_ else \
+        _EQUALSPACED_(n, repr(value))
+    return Error(_immutable_, txt=t)
+
+
 def _incompatible(this):
     '''(INTERNAL) Format an C{"incompatible with ..."} text.
     '''

pygeodesy/etm.py

@@ -67,7 +67,7 @@ from pygeodesy.basics import _isin, map1, neg, neg_, _xinstanceof
 from pygeodesy.constants import EPS, EPS02, PI_2, PI_4, _K0_UTM, \
                              _1_EPS, _0_0, _0_1, _0_5, _1_0, _2_0, \
                              _3_0, _90_0, isnear0, isnear90
-from pygeodesy.constants import _4_0  # PYCHOK used!
+from pygeodesy.constants import _0_75, _4_0  # PYCHOK used!
 from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 # from pygeodesy.elliptic import Elliptic  # _MODS
@@ -75,8 +75,8 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  _EWGS84
 # from pygeodesy.fsums import Fsum  # from .fmath
 from pygeodesy.fmath import cbrt, hypot, hypot1, hypot2,  Fsum
 from pygeodesy.interns import _COMMASPACE_, _DMAIN_, _near_, _SPACE_, _spherical_
-from pygeodesy.karney import _K_2_4, _copyBit, _diff182, _fix90, _norm2, \
-                            _norm180, _tand, _unsigned2
+from pygeodesy.karney import _K_2_4, _diff182, _fix90, _norm2, _norm180, \
+                             _signBit, _tand, _unsigned2
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
 from pygeodesy.named import callername, _incompatible, _NamedBase, \
                            _ALL_LAZY, _MODS
@@ -93,7 +93,7 @@ from pygeodesy.utm import _cmlon, _LLEB, _parseUTM5, _toBand, _toXtm8, \
 from math import asinh, degrees, radians, sinh, sqrt
 
 __all__ = _ALL_LAZY.etm
-__version__ = '25.05.12'
+__version__ = '25.09.15'
 
 _OVERFLOW = _1_EPS**2  # ~2e+31
 _TAYTOL   =  pow(EPS,  0.6)
@@ -410,7 +410,7 @@ class ExactTransverseMercator(_NamedBase):
     def _Ev_3cKE_4(self):
         '''(INTERNAL) Get and cache C{_Ev.cKE * 3 / 4}.
         '''
-        return self._Ev_cKE * 0.75  # _0_75
+        return self._Ev_cKE * _0_75
 
     @Property_RO
     def _Ev_5cKE_4(self):
@@ -790,7 +790,7 @@ class ExactTransverseMercator(_NamedBase):
             mu = mu / d2
             mv = mv / d2
         else:
-            mu, mv = map1(_overflow, mu, mv)
+            mu, mv = map1(_copysignOVERFLOW, mu, mv)
         xi = self._Eu.fE(snu, cnu, dnu) - mu
         v -= self._Ev.fE(snv, cnv, dnv) - mv
         return xi, v, d2
@@ -910,12 +910,12 @@ class ExactTransverseMercator(_NamedBase):
         if d1 > EPS02:  # _EPSmin
             t1 = snu * dnv / sqrt(d1)
         else:  # like atan(overflow) = pi/2
-            t1, d1 = _overflow(snu), 0
+            t1, d1 = _copysignOVERFLOW(snu), 0
         d2 = cnu2 * self._mu + cnv**2 * mv
         if d2 > EPS02:  # _EPSmin
             t2 = sinh(e * asinh(e * snu / sqrt(d2)))
         else:
-            t2, d2 = _overflow(snu), 0
+            t2, d2 = _copysignOVERFLOW(snu), 0
         # psi = asinh(t1) - asinh(t2)
         # taup = sinh(psi)
         taup = t1 * hypot1(t2) - t2 * hypot1(t1)
@@ -1026,10 +1026,10 @@ _allPropertiesOf_n(22, ExactTransverseMercator, Property_RO)  # PYCHOK assert _R
 del _0_1, _allPropertiesOf_n, EPS, _1_EPS, _EWGS84
 
 
-def _overflow(x):
+def _copysignOVERFLOW(x):
     '''(INTERNAL) Like C{copysign0(OVERFLOW, B{x})}.
     '''
-    return _copyBit(_OVERFLOW, x)
+    return (-_OVERFLOW) if _signBit(x) else _OVERFLOW
 
 
 def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, **name):

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, _1_6th, _0_25, _1_3rd, _0_5, _1_0, \
-                               _1_5, _copysign_0_0, isfinite, remainder
+                               _0_0, _0_125, _0_25, _0_5, _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,10 +25,12 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '25.06.03'
+__version__ = '25.09.15'
 
 # 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
 _h_lt_b_ = 'abs(h) < abs(b)'
 

pygeodesy/geodesicx/__init__.py

@@ -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__ = '25.06.04'
+__version__ = '25.09.02'
 
 # **) MIT License
 #

pygeodesy/geodesicx/__main__.py

@@ -46,6 +46,7 @@ def _main(**C4order):  # PYCHOK no cover
 from sys import argv  # .internals._isPyChOK
 _main(C4order=int(argv[1])) if len(argv) == 2 and argv[1].isdigit() else _main()
 
+
 # % python3.13 -m pygeodesy.geodesicx
 # pygeodesy.geodesicx 25.06.01: C4order=30, C4n=5425, C4u=5107, C4u_n=94.1%, C4x=465, C4t=tuple, C4z=166008, geographiclib 2.0 (pygeodesy 25.5.28 Python 3.13.3 64bit arm64 macOS 15.5)