pygeodesy 24.8.4__py2.py3-none-any.whl → 24.9.9__py2.py3-none-any.whl

pygeodesy/elliptic.py

@@ -65,7 +65,8 @@ in U{B. C. Carlson, Computation of real or complex elliptic integrals
 The computation of the Jacobi elliptic functions uses the algorithm
 given in U{R. Bulirsch, Numerical Calculation of Elliptic Integrals
 and Elliptic Functions<https://DOI.org/10.1007/BF01397975>},
-Numerische Mathematik 7, 78--90 (1965).
+Numerische Mathematik 7, 78--90 (1965) or optionally the C{Jacobi
+amplitude} in method L{Elliptic.sncndn<pygeodesy.Elliptic.sncndn>}.
 
 The notation follows U{NIST Digital Library of Mathematical Functions
 <https://DLMF.NIST.gov>} chapters U{19<https://DLMF.NIST.gov/19>} and
@@ -75,13 +76,13 @@ U{22<https://DLMF.NIST.gov/22>}.
 from __future__ import division as _; del _  # PYCHOK semicolon
 
 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, _1_64th, \
-                               _0_25, _0_5, _1_0, _2_0, _N_2_0, \
-                               _3_0, _4_0, _6_0, _8_0, _180_0, \
-                               _360_0, _over
+from pygeodesy.constants import EPS, INF, NAN, PI, PI_2, PI_4, _0_0, \
+                               _0_25, _0_5, _1_0, _2_0, _N_2_0, _3_0, \
+                               _4_0, _6_0, _8_0, _64_0, _180_0, _360_0, \
+                               _EPStol as _TolJAC, _over, \
+                               _EPSjam as _TolJAM  # PYCHOK used!
 # from pygeodesy.errors import _ValueError  # from .fmath
-from pygeodesy.fmath import fdot, hypot1, zqrt,  _ValueError
+from pygeodesy.fmath import favg, hypot1, zqrt,  _ValueError
 from pygeodesy.fsums import Fsum, _sum
 # from pygeodesy.internals import _dunder_nameof  # from .lazily
 from pygeodesy.interns import NN, _delta_, _DOT_, _f_, _invalid_, \
@@ -94,16 +95,16 @@ from pygeodesy.props import _allPropertiesOf_n, Property_RO, _update_all
 from pygeodesy.units import Scalar, Scalar_
 # from pygeodesy.utily import sincos2 as _sincos2  # from .karney
 
-from math import asinh, atan, atan2, ceil, cosh, fabs, floor, \
-                 radians, sin, sqrt, tanh
+from math import asin, asinh, atan, atan2, ceil, cosh, fabs, floor, \
+                 radians, sin, sinh, sqrt, tan, tanh
 
 __all__ = _ALL_LAZY.elliptic
-__version__ = '24.05.18'
+__version__ = '24.09.06'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
 _TolRG0 = _TolJAC   * 2.7
-_TRIPS  =  21  # Max depth, 7 might be sufficient
+_TRIPS  =  25  # Max depth, 6-7 might be sufficient
 
 
 class _Cs(object):
@@ -127,6 +128,19 @@ class _Dsum(list):
         return self
 
 
+class _Dadd(_Dsum):
+    '''(INTERNAL) Deferred C{Fsum} for C{_List.amrs4}.
+    '''
+    def __init__(self, mul):
+        self._mul = mul
+
+    def __add__(self, x):
+        self += x
+        r = self(self._mul)
+        _ = self.pop()
+        return r  # Fsum or float
+
+
 class Elliptic(_Named):
     '''Elliptic integrals and functions.
 
@@ -407,7 +421,6 @@ class Elliptic(_Named):
         # Applied Math. and Computation 218, 7005-7013 (2012)
         # <https://DOI.org/10.1016/j.amc.2011.12.021>
         _Phi2 = Phi.fsum2f_  # aggregate
-        _abs  = fabs
         for i in range(1, _TRIPS):  # GEOGRAPHICLIB_PANIC
             sn, cn, dn = self._sncndn3(phi)
             if dn:
@@ -415,7 +428,7 @@ class Elliptic(_Named):
                 phi, d = _Phi2((r - sn) / dn)
             else:  # PYCHOK no cover
                 d = _0_0  # XXX continue?
-            if _abs(d) < _TolJAC:  # 3-4 trips
+            if fabs(d) < _TolJAC:  # 3-4 trips
                 _iterations(self, i)
                 break
         else:  # PYCHOK no cover
@@ -505,7 +518,8 @@ class Elliptic(_Named):
             return ei
 
         return self._fXf(phi_or_sn, cn, dn, self.cE,
-                                            self.deltaE, _fE)
+                                            self.deltaE, _fE,
+                         k2_0=self.k2==0)
 
     def fEd(self, deg):
         '''The incomplete integral of the second kind with
@@ -561,7 +575,8 @@ class Elliptic(_Named):
             return r
 
         return self._fXf(phi_or_sn, cn, dn, self.cK,
-                                            self.deltaF, _fF)
+                                            self.deltaF, _fF,
+                         k2_0=self.k2==0, kp2_0=self.kp2==0)
 
     def fG(self, phi_or_sn, cn=None, dn=None):
         '''Legendre's geodesic longitude integral in terms of
@@ -648,12 +663,16 @@ class Elliptic(_Named):
 
         return self._fXf(phi_or_sn, cn, dn, cX, deltaX, _fX)
 
-    def _fXf(self, phi_or_sn, cn, dn, cX, deltaX, fX):
+    def _fXf(self, phi_or_sn, cn, dn, cX, deltaX, fX, k2_0=False, kp2_0=False):
         '''(INTERNAL) Helper for C{.fD}, C{.fE}, C{.fF} and C{._fXa}.
         '''
         self._iteration = 0  # aggregate
         phi = sn = phi_or_sn
         if cn is dn is None:  # fX(phi) call
+            if k2_0:  # C++ version 2.4
+                return phi
+            elif kp2_0:
+                return asinh(tan(phi))
             sn, cn, dn = self._sncndn3(phi)
             if fabs(phi) >= PI:
                 return (deltaX(sn, cn, dn) + phi) * cX / PI_2
@@ -668,6 +687,51 @@ class Elliptic(_Named):
             xi = fX(sn, cn, dn) if cn > 0 else cX
         return copysign0(xi, sn)
 
+    def _jam(self, x):
+        '''Jacobi amplitude function.
+
+           @return: C{phi} (C{float}).
+        '''
+        # implements DLMF Sec 22.20(ii), see also U{Sala
+        # (1989)<https://doi.org/10.1137/0520100>}, Sec 5
+        if self.k2:
+            if self.kp2:
+                r, ac = self._jamac2
+                x    *= r  # phi
+                for a, c in ac:
+                    p = x
+                    x = favg(asin(c * sin(x) / a), x)
+                if self.k2 < 0:  # Sala Eq. 5.8
+                    x = p - x
+            else:  # PYCHOK no cover
+                x = atan(sinh(x))  # gd(x)
+        return x
+
+    @Property_RO
+    def _jamac2(self):
+        '''(INTERNAL) Get Jacobi amplitude 2-tuple C{(r, ac)}.
+        '''
+        a = r = _1_0
+        b, c = self.kp2, self.k2
+        # assert b and c
+        if c < 0:  # Sala Eq. 5.8
+            r  =  sqrt(b)
+            b  = _1_0 / b
+#           c *=  b  # unused
+        ac = []  # [(a, sqrt(c))] unused
+        for i in range(1, _TRIPS):  # GEOGRAPHICLIB_PANIC
+            b = sqrt(a * b)
+            c = favg(a, -b)
+            a = favg(a,  b)  # == PI_2 / K
+            ac.append((a, c))
+            if c <= (a * _TolJAM):  # 7 trips, quadratic
+                _iterations(self, i)
+                break
+        else:  # PYCHOK no cover
+            raise _convergenceError(c / a, _TolJAM)
+        r *= a * float(1 << i)  # 2**i == 2**len(ac)
+        return r, tuple(reversed(ac))
+
     @Property_RO
     def k2(self):
         '''Get k^2, the square of the modulus (C{float}).
@@ -723,38 +787,46 @@ class Elliptic(_Named):
         # Pi(alpha2, 1) = inf
         # G( alpha2, 1) = H(alpha2, 1) = RC(1, alphap2)
 
-    def sncndn(self, x):
-        '''The Jacobi elliptic function.
+    def sncndn(self, x, jam=False):
+        '''The Jacobi amplitude and elliptic function.
 
            @arg x: The argument (C{float}).
+           @kwarg jam: If C{True}, use the Jacobi amplitude otherwise the
+                       Bulirsch' function (C{bool}).
 
-           @return: An L{Elliptic3Tuple}C{(sn, cn, dn)} with
-                    C{*n(B{x}, k)}.
+           @return: An L{Elliptic3Tuple}C{(sn, cn, dn)} with C{*n(B{x}, k)}.
 
            @raise EllipticError: No convergence.
         '''
         self._iteration = 0  # reset
-        try:  # Bulirsch's sncndn routine, p 89.
+        try:
             if self.kp2:
-                c, d, cd, mn = self._sncndn4
-                dn = _1_0
-                sn, cn = _sincos2(x * cd)
-                if sn:
-                    a  = cn / sn
-                    c *= a
-                    for m, n in reversed(mn):
-                        a *= c
-                        c *= dn
-                        dn = (n + a) / (m + a)
-                        a  =  c / m
-                    a  = _1_0 / hypot1(c)
-                    sn =  neg(a) if _signBit(sn) else a
-                    cn =  c * sn
-                    if d and _signBit(self.kp2):
-                        cn, dn = dn, cn
-                        sn = sn / d  # /= chokes PyChecker
+                if jam:  # Jacobi amplitude, C++ version 2.4
+                    sn, cn, dn = self._sncndn3(self._jam(x))
+
+                else:  # Bulirsch's sncndn routine, p 89 of
+                    # Numerische Mathematik 7, 78-90 (1965).
+                    # Implements DLMF Eqs 22.17.2 - 22.17.4,
+                    # but only good for .k2 > 1 or .kp2 < 0
+                    c, d, cd, mn = self._sncndn4
+                    dn = _1_0
+                    sn, cn = _sincos2(x * cd)
+                    if sn:
+                        a  = cn / sn
+                        c *= a
+                        for m, n in mn:
+                            a *= c
+                            c *= dn
+                            dn = (n + a) / (m + a)
+                            a  =  c / m
+                        a  = _1_0 / hypot1(c)
+                        sn =  neg(a) if _signBit(sn) else a
+                        cn =  sn * c
+                        if d:  # and _signBit(self.kp2):  # implied
+                            cn, dn = dn, cn
+                            sn = sn / d  # /= chokes PyChecker
             else:
-                sn = tanh(x)
+                sn = tanh(x)  # accurate for large abs(x)
                 cn = dn = _1_0 / cosh(x)
 
         except Exception as e:
@@ -763,7 +835,7 @@ class Elliptic(_Named):
         return Elliptic3Tuple(sn, cn, dn, iteration=self._iteration)
 
     def _sncndn3(self, phi):
-        '''(INTERNAL) Helper for C{.fEinv} and C{._fXf}.
+        '''(INTERNAL) Helper for C{.fEinv}, C{._fXf} and C{.sncndn}.
         '''
         sn, cn = _sincos2(phi)
         return sn, cn, self.fDelta(sn, cn)
@@ -772,29 +844,27 @@ class Elliptic(_Named):
     def _sncndn4(self):
         '''(INTERNAL) Get Bulirsch' 4-tuple C{(c, d, cd, mn)}.
         '''
-        # Bulirsch's sncndn routine, p 89.
-        d, mc = 0, self.kp2
-        if _signBit(mc):
-            d  = _1_0 - mc
-            mc =  neg(mc / d)
-            d  =  sqrt(d)
-
-        mn, a = [], _1_0
+        d, b = 0, self.kp2
+        if _signBit(b):
+            d = _1_0 - b
+            b =  neg(b / d)
+            d =  sqrt(d)
+        ab, a = [], _1_0
         for i in range(1, _TRIPS):  # GEOGRAPHICLIB_PANIC
-            mc = sqrt(mc)
-            mn.append((a, mc))
-            c = (a + mc) * _0_5
-            r =  fabs(mc -  a)
-            t = _TolJAC  *  a
-            if r <= t:  # 6 trips, quadratic
+            b = sqrt(b)
+            ab.append((a, b))
+            c = favg(a,  b)
+            r = fabs(a - b)
+            if r <= (a * _TolJAC):  # 6 trips, quadratic
                 _iterations(self, i)
                 break
-            mc *= a
-            a   = c
+            t  = a
+            b *= a
+            a  = c
         else:  # PYCHOK no cover
-            raise _convergenceError(r, t)
+            raise _convergenceError(r / t, _TolJAC)
         cd = (c * d) if d else c
-        return c, d, cd, mn
+        return c, d, cd, tuple(reversed(ab))
 
     @staticmethod
     def fRC(x, y):
@@ -882,7 +952,7 @@ class Elliptic(_Named):
             raise _ellipticError(Elliptic._RFRD, x, y, z, m, cause=e)
         return float(R)
 
-_allPropertiesOf_n(15, Elliptic)  #  # PYCHOK assert, see Elliptic.reset
+_allPropertiesOf_n(16, Elliptic)  #  # PYCHOK assert, see Elliptic.reset
 
 
 class EllipticError(_ValueError):
@@ -901,25 +971,18 @@ class Elliptic3Tuple(_NamedTuple):
 class _List(list):
     '''(INTERNAL) Helper for C{_RD}, C{_RF3} and C{_RJ}.
     '''
-    _a0   = None
-#   _xyzp = ()
+    _a0 = None
 
     def __init__(self, *xyzp):  # x, y, z [, p]
         list.__init__(self, xyzp)
-        self._xyzp = xyzp
 
     def a0(self, n):
         '''Compute the initial C{a}.
         '''
-        t = tuple(self)
-        m = n - len(t)
-        if m > 0:
-            t += t[-1:] * m
-        try:
-            a = Fsum(*t).fover(n)
-        except ValueError:  # Fsum(NAN) exception
-            a = _sum(t) / n
-        self._a0 = a
+        A = _Dsum(self)
+        while len(A) < n:
+            A += A[-1]
+        self._a0 = a = float(A(_1_0 / n))
         return a
 
     def amrs4(self, inst, y, Tol):
@@ -929,20 +992,22 @@ class _List(list):
         L = self
         a = L.a0(5 if y else 3)
         m = 1
-        t = max(fabs(a - _) for _ in L) / Tol
+        t = max(fabs(a - _) for _ in L) / Tol  # thresh
         for i in range(_TRIPS):
             d = fabs(a * m)
             if d > t:  # 3-6 trips
                 _iterations(inst, i)
                 break
             s = map2(sqrt, L)  # sqrt(x), srqt(y), sqrt(z) [, sqrt(p)]
-            try:
-                r = fdot(s[:3], s[1], s[2], s[0])  # sqrt(x) * sqrt(y) + ...
-            except ValueError:  # Fsum(NAN) exception
-                r = _sum(s[i] * s[(i + 1) % 3] for i in range(3))
-            L[:] = ((r + _) * _0_25 for _ in L)
-            a    =  (r + a) * _0_25
+            # Deferred fdot(s[:3], s[1], s[2], s[0]) + ...
+            Q = _Dadd(_0_25)
+            Q += s[0] * s[1]
+            Q += s[1] * s[2]
+            Q += s[2] * s[0]
+            L[:] = (float(Q + _) for _ in L)
+            a    =  float(Q + a)
             if y:  # yield only if used
+                r = _sum(Q)  # fdot
                 yield a, m, r, s  # L[2] is next z
             m *= 4
         else:  # PYCHOK no cover
@@ -967,14 +1032,15 @@ def _ab2(inst, x, y):
         b, a = a, b
     for i in range(_TRIPS):
         yield a, b  # xi, yi
-        d =  fabs(a - b)
-        t = _TolRG0 * a
-        if d <= t:  # 3-4 trips
+        d = fabs(a - b)
+        if d <= (a * _TolRG0):  # 3-4 trips
             _iterations(inst, i)
             break
-        a, b = ((a + b) * _0_5), sqrt(a * b)
+        t = a
+        a = favg(t,  b)
+        b = sqrt(t * b)
     else:  # PYCHOK no cover
-        raise _convergenceError(d, t)
+        raise _convergenceError(d / t, _TolRG0)
 
 
 def _convergenceError(d, tol, **thresh):
@@ -1083,10 +1149,10 @@ def _RD(inst, x, y, z, *over):
     z  = (x + y) / _3_0
     z2 =  z**2
     return _Horner(S(_1_0), sqrt(a) * a * m,
-                   xy        - _6_0 * z2,
-                  (xy * _3_0 - _8_0 * z2) * z,
-                  (xy - z2)  * _3_0 * z2,
-                   xy * z2 * z, *over)  # Fsum
+                  (xy        - z2 * _6_0),
+                  (xy * _3_0 - z2 * _8_0) * z,
+                  (xy -  z2) * z2 * _3_0,
+                  (xy *  z2  * z), *over)  # Fsum
 
 
 def _rF2(inst, x, y):  # 2-arg version, z=0
@@ -1160,7 +1226,7 @@ def _RJ(inst, x, y, z, p, *over):
             if d:
                 if n:
                     rc = _rC(inst, _1_0, n / d**2 + _1_0)
-                    n *= _1_64th  # /= chokes PyChecker
+                    n  =  n / _64_0  # /= chokes PyChecker
                 else:
                     rc = _1_0  # == _rC(None, _1_0, _1_0)
                 S += rc / (d * m)

pygeodesy/epsg.py

@@ -17,7 +17,7 @@ including coverage of UPS as zone C{0}.
 from pygeodesy.basics import isint, isstr, _xinstanceof
 from pygeodesy.errors import _ValueError
 from pygeodesy.interns import NN, _N_, _NS_, _S_, _SPACE_
-from pygeodesy.lazily import _ALL_LAZY, _ALL_OTHER
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 from pygeodesy.namedTuples import UtmUps2Tuple
 from pygeodesy.props import Property_RO
 from pygeodesy.streprs import Fmt
@@ -28,7 +28,7 @@ from pygeodesy.utmupsBase import _to3zBhp, _UPS_ZONE, _UTM_ZONE_MIN, \
                                  _UTM_ZONE_MAX, _UTMUPS_ZONE_INVALID
 
 __all__ = _ALL_LAZY.epsg
-__version__ = '24.05.18'
+__version__ = '24.08.05'
 
 # _EPSG_INVALID = _UTMUPS_ZONE_INVALID
 _EPSG_N_01 = 32601  # EPSG code for UTM zone 01 N
@@ -219,7 +219,7 @@ def encode(zone, hemipole=NN, band=NN):
     return e
 
 
-__all__ += _ALL_OTHER(decode2, encode)
+__all__ += _ALL_DOCS(decode2, encode)
 
 # **) MIT License
 #

pygeodesy/etm.py

@@ -73,10 +73,9 @@ from pygeodesy.elliptic import _ALL_LAZY, Elliptic
 # from pygeodesy.errors import _incompatible  # from .named
 # from pygeodesy.fsums import Fsum  # from .fmath
 from pygeodesy.fmath import cbrt, hypot, hypot1, hypot2,  Fsum
-from pygeodesy.interns import _COMMASPACE_, _DASH_, _near_, _SPACE_, \
-                              _spherical_
-from pygeodesy.karney import _copyBit, _diff182, _fix90, _norm2, _norm180, \
-                             _tand, _unsigned2
+from pygeodesy.interns import _COMMASPACE_, _near_, _SPACE_, _spherical_
+from pygeodesy.karney import _K_2_4, _copyBit, _diff182, _fix90, \
+                             _norm2, _norm180, _tand, _unsigned2
 # from pygeodesy.lazily import _ALL_LAZY  # from .elliptic
 from pygeodesy.named import callername, _incompatible, _NamedBase
 from pygeodesy.namedTuples import Forward4Tuple, Reverse4Tuple
@@ -92,7 +91,7 @@ from pygeodesy.utm import _cmlon, _LLEB, _parseUTM5, _toBand, _toXtm8, \
 from math import asinh, atan2, degrees, radians, sinh, sqrt
 
 __all__ = _ALL_LAZY.etm
-__version__ = '24.06.11'
+__version__ = '24.09.06'
 
 _OVERFLOW = _1_EPS**2  # about 2e+31
 _TAYTOL   =  pow(EPS, 0.6)
@@ -431,13 +430,15 @@ class ExactTransverseMercator(_NamedBase):
 
     f = flattening
 
-    def forward(self, lat, lon, lon0=None, **name):  # MCCABE 13
+    def forward(self, lat, lon, lon0=None, jam=_K_2_4, **name):  # MCCABE 13
         '''Forward projection, from geographic to transverse Mercator.
 
            @arg lat: Latitude of point (C{degrees}).
            @arg lon: Longitude of point (C{degrees}).
            @kwarg lon0: Central meridian (C{degrees180}), overriding
                         the default if not C{None}.
+           @kwarg jam: If C{True}, use the C{Jacobi amplitude}
+                       otherwise C{Bulirsch}' function (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: L{Forward4Tuple}C{(easting, northing, gamma, scale)}.
@@ -473,7 +474,7 @@ class ExactTransverseMercator(_NamedBase):
             tau, lam = _tand(lat), radians(lon)
             u, v = self._zetaInv2(self._E.es_taupf(tau), lam)
 
-        sncndn6 = self._sncndn6(u, v)
+        sncndn6 = self._sncndn6(u, v, jam=jam)
         y, x, _ = self._sigma3(v,  *sncndn6)
         g, k    = (lon, self.k0) if isnear90(lat) else \
                   self._zetaScaled(sncndn6, ll=False)
@@ -668,13 +669,15 @@ class ExactTransverseMercator(_NamedBase):
         self._mu = mu
         self._mv = mv
 
-    def reverse(self, x, y, lon0=None, **name):
+    def reverse(self, x, y, lon0=None, jam=_K_2_4, **name):
         '''Reverse projection, from Transverse Mercator to geographic.
 
            @arg x: Easting of point (C{meters}).
            @arg y: Northing of point (C{meters}).
            @kwarg lon0: Optional central meridian (C{degrees180}),
                         overriding the default (C{iff not None}).
+           @kwarg jam: If C{True}, use the C{Jacobi amplitude}
+                       otherwise C{Bulirsch}' function (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: L{Reverse4Tuple}C{(lat, lon, gamma, scale)}.
@@ -706,7 +709,7 @@ class ExactTransverseMercator(_NamedBase):
             v = self._Ev_cK
 
         if v or u != self._Eu_cK:
-            g, k, lat, lon = self._zetaScaled(self._sncndn6(u, v))
+            g, k, lat, lon = self._zetaScaled(self._sncndn6(u, v, jam=jam))
         else:  # PYCHOK no cover
             g, k, lat, lon = _0_0, self.k0, _90_0, _0_0
 
@@ -866,12 +869,12 @@ class ExactTransverseMercator(_NamedBase):
 
         return u, v, t, C
 
-    def _sncndn6(self, u, v):
+    def _sncndn6(self, u, v, **jam):
         '''(INTERNAL) Get 6-tuple C{(snu, cnu, dnu, snv, cnv, dnv)}.
         '''
         # snu, cnu, dnu = self._Eu.sncndn(u)
         # snv, cnv, dnv = self._Ev.sncndn(v)
-        return self._Eu.sncndn(u) + self._Ev.sncndn(v)
+        return self._Eu.sncndn(u, **jam) + self._Ev.sncndn(v, **jam)
 
     def toStr(self, joined=_COMMASPACE_, **kwds):  # PYCHOK signature
         '''Return a C{str} representation.
@@ -1094,67 +1097,76 @@ def toEtm8(latlon, lon=None, datum=None, Etm=Etm, falsed=True,
                         n, latlon, d.exactTM, Error=ETMError)
 
 
-if __name__ == '__main__':  # MCCABE 13
-
-    from pygeodesy import fstr, KTransverseMercator, printf
-    from pygeodesy.internals import _usage
-    from sys import argv, exit as _exit
-
-    # mimick some of I{Karney}'s utility C{TransverseMercatorProj}
-    _f = _r = _s = _t = False
-    _p = -6
-    _as = argv[1:]
-    while _as and _as[0].startswith(_DASH_):
-        _a = _as.pop(0)
-        if len(_a) < 2:
-            _exit('%s: option %r invalid' % (_usage(*argv), _a))
-        elif '-forward'.startswith(_a):
-            _f, _r = True, False
-        elif '-reverse'.startswith(_a):
-            _f, _r = False, True
-        elif '-precision'.startswith(_a):
-            _p = int(_as.pop(0))
-        elif '-series'.startswith(_a):
-            _s, _t = True, False
-        elif _a == '-t':
-            _s, _t = False, True
-        elif '-help'.startswith(_a):
+if __name__ == '__main__':  # MCCABE 16
+
+    def _main():
+
+        from pygeodesy import fstr, KTransverseMercator
+#       from pygeodesy.interns import _DASH_  # from internals
+        from pygeodesy.internals import printf, _usage,  _DASH_
+        from sys import argv, exit as _exit
+
+        def _help():
             _exit(_usage(argv[0], '[-s | -t ]',
                                   '[-p[recision] <ndigits>',
                                   '[-f[orward] <lat> <lon>',
                                   '|-r[everse] <easting> <northing>',
                                   '|<lat> <lon>]',
                                   '|-h[elp]'))
+
+        # mimick some of I{Karney}'s utility C{TransverseMercatorProj}
+        _f = _r = _s = _t = False
+        _p = -6
+        _as = argv[1:]
+        while _as and _as[0].startswith(_DASH_):
+            _a = _as.pop(0)
+            if len(_a) < 2:
+                _exit('%s: option %r invalid' % (_usage(*argv), _a))
+            elif '-forward'.startswith(_a):
+                _f, _r = True, False
+            elif '-reverse'.startswith(_a):
+                _f, _r = False, True
+            elif '-precision'.startswith(_a):
+                _p = int(_as.pop(0))
+            elif '-series'.startswith(_a):
+                _s, _t = True, False
+            elif _a == '-t':
+                _s, _t = False, True
+            elif '-help'.startswith(_a):
+                _help()
+            else:
+                _exit('%s: option %r not supported' % (_usage(*argv), _a))
+
+        if len(_as) > 1:
+            f2 = map1(float, *_as[:2])
+        else:
+            printf('%s ...: incomplete', _usage(*argv))
+            _help()
+
+        if _s:  # -series
+            tm = KTransverseMercator()
+        else:
+            tm = ExactTransverseMercator(extendp=_t)
+
+        if _f:
+            t = tm.forward(*f2)
+        elif _r:
+            t = tm.reverse(*f2)
         else:
-            _exit('%s: option %r not supported' % (_usage(*argv), _a))
-    if len(_as) > 1:
-        f2 = map1(float, *_as[:2])
-    else:
-        _exit('%s ...: incomplete' % (_usage(*argv),))
-
-    if _s:  # -series
-        tm = KTransverseMercator()
-    else:
-        tm = ExactTransverseMercator(extendp=_t)
-
-    if _f:
-        t = tm.forward(*f2)
-    elif _r:
-        t = tm.reverse(*f2)
-    else:
-        t = tm.forward(*f2)
+            t = tm.forward(*f2)
+            printf('%s: %s', tm.classname, fstr(t, prec=_p, sep=_SPACE_))
+            t = tm.reverse(t.easting, t.northing)
         printf('%s: %s', tm.classname, fstr(t, prec=_p, sep=_SPACE_))
-        t = tm.reverse(t.easting, t.northing)
-    printf('%s: %s', tm.classname, fstr(t, prec=_p, sep=_SPACE_))
 
+    _main()
 
-# % python3 -m pygeodesy.etm -p 12 33.33 44.44
+# % python3.12 -m pygeodesy.etm -p 12 33.33 44.44
 # ExactTransverseMercator: 4276926.11480390653 4727193.767015309073 28.375536563148 1.233325101778
 # ExactTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
 
-# % python3 -m pygeodesy.etm -s -p 12 33.33 44.44
-# KTransverseMercator: 4276926.114803904667 4727193.767015310004 28.375536563148 1.233325101778
-# KTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
+# % python3.12 -s -m pygeodesy.etm -p 12 33.33 44.44
+# ExactTransverseMercator: 4276926.11480390653 4727193.767015309073 28.375536563148 1.233325101778
+# ExactTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
 
 # % echo 33.33 44.44 | .../bin/TransverseMercatorProj
 # 4276926.114804 4727193.767015 28.375536563148 1.233325101778