pygeodesy 25.4.8__py2.py3-none-any.whl → 25.4.25__py2.py3-none-any.whl

pygeodesy/trf.py

@@ -69,16 +69,18 @@ en/how-to-deal-with-etrs89-datum-and-time-dependent-transformation-parameters-45
 @var RefFrames.WGS84g1762: RefFrame(name='WGS84g1762', epoch=2005, datum=Datums.GRS80) .Xforms=(0, 0)
 '''
 
-from pygeodesy.basics import map1, neg, isidentifier, isstr, _xinstanceof, _xscalar
+from pygeodesy.basics import _isin, map1, neg, isidentifier, isstr, _xinstanceof, \
+                             _xscalar,  typename
 from pygeodesy.constants import _float as _F, _0_0s, _0_0, _0_001, _0_5, _1_0
 from pygeodesy.datums import Datums, _earth_datum, _equall, _GDA2020_, _Names7, \
                             _negastr, Transform, _WGS84,  _EWGS84, _operator
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.errors import TRFError, _xattr, _xellipsoidall, _xkwds, _xkwds_item2
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import MISSING, NN, _AT_, _COMMASPACE_, _conversion_, \
-                             _datum_, _DOT_, _exists_, _invalid_, _MINUS_, \
-                             _NAD83_, _no_, _PLUS_, _reframe_, _s_, _SPACE_, \
-                             _STAR_, _to_, _vs_, _WGS84_, _x_, _intern as _i
+                             _datum_, _DMAIN_, _DOT_, _exists_, _invalid_, _MINUS_, \
+                             _NAD83_, _no_, _PLUS_, _reframe_, _s_, _SPACE_, _to_, \
+                             _STAR_, _vs_, _WGS84_, _x_, _intern as _i
 # from pygeodesy.lazily import _ALL_LAZY  # from .units
 from pygeodesy.named import ADict, classname, _lazyNamedEnumItem as _lazy, _name2__, \
                            _Named, _NamedEnum, _NamedEnumItem, _NamedTuple,  Fmt, unstr
@@ -91,7 +93,7 @@ from math import ceil as _ceil, fabs
 # import operator as _operator  # from .datums
 
 __all__ = _ALL_LAZY.trf
-__version__ = '24.10.14'
+__version__ = '25.04.14'
 
 _EP0CH    =  Epoch(0, low=0)
 _Es       = {_EP0CH: _EP0CH}  # L{Epoch}s, deleted below
@@ -176,9 +178,9 @@ class RefFrame(_NamedEnumItem):
 
            @raise TypeError: Invalid B{C{datum}}.
         '''
-        if datum in (_GRS80, None):
+        if _isin(datum, None, _GRS80):
             pass
-        elif datum in (_WGS84, _EWGS84):
+        elif _isin(datum, _WGS84, _EWGS84):
             self._datum = _WGS84
         else:
             _earth_datum(self, datum, raiser=_datum_)
@@ -1062,8 +1064,8 @@ def _toRefFrame(point, reframe2, reframe=None, epoch=None,
     e2 =  e1 if epoch2 is None else Epoch(epoch2=epoch2)
     t0 = _toTransform0(r1.name, e1, reframe2.name, e2)
     if t0 is None:
-        t = _SPACE_(RefFrame.__name__, _AT_(r1.name, e1),
-                           _to_, _AT_(reframe2.name, e2))
+        t = _SPACE_(typename(RefFrame), _AT_(r1.name, e1),
+                            _to_, _AT_(reframe2.name, e2))
         raise TRFError(_no_(_conversion_), txt=t)
 
     name, LatLon_kwds = _name2__(name_LatLon_kwds)
@@ -1732,7 +1734,7 @@ trfXform(_WGS84g1150_,  _ITRF2000_, epoch=_E(2004), xform=_P_0_0s, rates=_P_0_0s
 
 del _E, _Es, _i, _P, _P_0_0s, _R, _Rs, _X, _Xs
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     def _main():
         from pygeodesy.basics import _args_kwds_names
@@ -1740,8 +1742,8 @@ if __name__ == '__main__':
         from pygeodesy import printf
         from time import localtime
 
-        D = date2epoch.__name__
-        E = epoch2date.__name__
+        D = typename(date2epoch)
+        E = typename(epoch2date)
         y = localtime()[0]
         for m in range(1, 13):
             for d in (1, 15, _mDays[m] - 1, _mDays[m]):

pygeodesy/triaxials.py

@@ -17,20 +17,20 @@ see the U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 @var Triaxials.Amalthea: Triaxial(name='Amalthea', a=125000, b=73000, c=64000, e2ab=0.658944, e2bc=0.231375493, e2ac=0.737856, volume=2446253479595252, area=93239507787.490371704, area_p=93212299402.670425415)
 @var Triaxials.Ariel: Triaxial(name='Ariel', a=581100, b=577900, c=577700, e2ab=0.01098327, e2bc=0.000692042, e2ac=0.011667711, volume=812633172614203904, area=4211301462766.580078125, area_p=4211301574065.829589844)
 @var Triaxials.Earth: Triaxial(name='Earth', a=6378173.435, b=6378103.9, c=6356754.399999999, e2ab=0.000021804, e2bc=0.006683418, e2ac=0.006705077, volume=1083208241574987694080, area=510065911057441.0625, area_p=510065915922713.6875)
-@var Triaxials.Enceladus: Triaxial(name='Enceladus', a=256600, b=251400, c=248300, e2ab=0.040119337, e2bc=0.024509841, e2ac=0.06364586, volume=67094551514082248, area=798618496278.596679688, area_p=798619018175.109863281)
+@var Triaxials.Enceladus: Triaxial(name='Enceladus', a=256600, b=251400, c=248300, e2ab=0.040119337, e2bc=0.024509841, e2ac=0.06364586, volume=67094551514082248, area=798618496278.596679688, area_p=798619018175.109985352)
 @var Triaxials.Europa: Triaxial(name='Europa', a=1564130, b=1561230, c=1560930, e2ab=0.003704694, e2bc=0.000384275, e2ac=0.004087546, volume=15966575194402123776, area=30663773697323.51953125, area_p=30663773794562.45703125)
 @var Triaxials.Io: Triaxial(name='Io', a=1829400, b=1819300, c=1815700, e2ab=0.011011391, e2bc=0.003953651, e2ac=0.014921506, volume=25313121117889765376, area=41691875849096.7421875, area_p=41691877397441.2109375)
 @var Triaxials.Mars: Triaxial(name='Mars', a=3394600, b=3393300, c=3376300, e2ab=0.000765776, e2bc=0.009994646, e2ac=0.010752768, volume=162907283585817247744, area=144249140795107.4375, area_p=144249144150662.15625)
-@var Triaxials.Mimas: Triaxial(name='Mimas', a=207400, b=196800, c=190600, e2ab=0.09960581, e2bc=0.062015624, e2ac=0.155444317, volume=32587072869017956, area=493855762247.691894531, area_p=493857714107.9375)
-@var Triaxials.Miranda: Triaxial(name='Miranda', a=240400, b=234200, c=232900, e2ab=0.050915557, e2bc=0.011070811, e2ac=0.061422691, volume=54926187094835456, area=698880863325.756958008, area_p=698881306767.950317383)
-@var Triaxials.Moon: Triaxial(name='Moon', a=1735550, b=1735324, c=1734898, e2ab=0.000260419, e2bc=0.000490914, e2ac=0.000751206, volume=21886698675223740416, area=37838824729886.09375, area_p=37838824733332.2265625)
+@var Triaxials.Mimas: Triaxial(name='Mimas', a=207400, b=196800, c=190600, e2ab=0.09960581, e2bc=0.062015624, e2ac=0.155444317, volume=32587072869017956, area=493855762247.691833496, area_p=493857714107.9375)
+@var Triaxials.Miranda: Triaxial(name='Miranda', a=240400, b=234200, c=232900, e2ab=0.050915557, e2bc=0.011070811, e2ac=0.061422691, volume=54926187094835456, area=698880863325.757080078, area_p=698881306767.950317383)
+@var Triaxials.Moon: Triaxial(name='Moon', a=1735550, b=1735324, c=1734898, e2ab=0.000260419, e2bc=0.000490914, e2ac=0.000751206, volume=21886698675223740416, area=37838824729886.09375, area_p=37838824733332.21875)
 @var Triaxials.Tethys: Triaxial(name='Tethys', a=535600, b=528200, c=525800, e2ab=0.027441672, e2bc=0.009066821, e2ac=0.036259685, volume=623086233855821440, area=3528073490771.394042969, area_p=3528074261832.738769531)
 @var Triaxials.WGS84_35: Triaxial(name='WGS84_35', a=6378172, b=6378102, c=6356752.314245179, e2ab=0.00002195, e2bc=0.006683478, e2ac=0.006705281, volume=1083207319768789942272, area=510065621722018.125, area_p=510065626587483.3125)
 '''
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import isLatLon, isscalar
+from pygeodesy.basics import _isin, isLatLon, isscalar
 from pygeodesy.constants import EPS, EPS0, EPS02, EPS4, INT0, PI2, PI_3, PI4, \
                                _EPS2e4, _SQRT2_2, float0_, isfinite, isnear1, _over, \
                                _0_0, _0_5, _1_0, _N_1_0, _64_0,  _4_0  # PYCHOK used!
@@ -40,10 +40,10 @@ from pygeodesy.datums import Datum, _spherical_datum, _WGS84,  Ellipsoid, _EWGS8
 from pygeodesy.errors import _AssertionError, _ValueError
 from pygeodesy.fmath import Fdot, fdot, fmean_, hypot, hypot_, norm2, sqrt0
 from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1f_
-from pygeodesy.interns import NN, _a_, _b_, _beta_, _c_, _distant_, _finite_, \
-                             _height_, _inside_, _near_, _negative_, _not_, \
-                             _NOTEQUAL_, _null_, _opposite_, _outside_, _SPACE_, \
-                             _spherical_, _too_, _x_, _y_
+from pygeodesy.interns import NN, _a_, _b_, _beta_, _c_, _distant_, _DMAIN_, \
+                             _finite_, _height_, _inside_, _near_, _negative_, \
+                             _not_, _NOTEQUAL_, _null_, _opposite_, _outside_, \
+                             _SPACE_, _spherical_, _too_, _x_, _y_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .vector3d
 from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _NamedEnum, \
                                 _NamedEnumItem, _Pass
@@ -59,7 +59,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d,  _ALL_LAZY, _MODS
 from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.triaxials
-__version__ = '24.11.24'
+__version__ = '25.04.14'
 
 _not_ordered_ = _not_('ordered')
 _omega_       = 'omega'
@@ -258,7 +258,7 @@ class Triaxial_(_NamedEnumItem):
 
     @Property_RO
     def _a2_b2(self):
-        '''(INTERNAL) Get C{(a/b)**2}.
+        '''(INTERNAL) Get C{(a / b)**2}.
         '''
         a, b, _ = self._abc3
         return (a / b)**2 if a != b else _1_0
@@ -321,7 +321,7 @@ class Triaxial_(_NamedEnumItem):
 
     @Property_RO
     def _c2_b2(self):
-        '''(INTERNAL) Get C{(c/b)**2}.
+        '''(INTERNAL) Get C{(c / b)**2}.
         '''
         _, b, c = self._abc3
         return (c / b)**2 if b != c else _1_0
@@ -422,7 +422,7 @@ class Triaxial_(_NamedEnumItem):
                 raise TriaxialError(x=x, y=y, z=z, cause=e)
             if h > 0 and self.sideOf(v, eps=EPS0) < 0:
                 h = -h  # inside
-        n = _name__(name, name__=self.height4)  # _DUNDER_nameof
+        n = _name__(name, name__=self.height4)  # typename
         return Vector4Tuple(x, y, z, h, iteration=i, name=n)
 
     @Property_RO
@@ -507,7 +507,7 @@ class Triaxial_(_NamedEnumItem):
                @return: 2-Tuple C{((a, b, c), ijk)} with C{a} >= C{b} >= C{c}
                         and C{ijk} a 3-tuple with the initial indices.
             '''
-            i, j, k = 0, 1, 2  # range(3)
+            i, j, k = range(3)
             if a < b:
                 a, b, i, j = b, a, j, i
             if a < c:
@@ -1245,9 +1245,9 @@ def hartzell4(pov, los=False, tri_biax=_WGS84, **name):
     '''Compute the intersection of a tri-/biaxial ellipsoid and a Line-Of-Sight from
        a Point-Of-View outside.
 
-       @arg pov: Point-Of-View outside the tri-/biaxial (C{Cartesian}, L{Ecef9Tuple}
+       @arg pov: Point-Of-View outside the tri-/biaxial (C{Cartesian}, L{Ecef9Tuple},
                  C{LatLon} or L{Vector3d}).
-       @kwarg los: Line-Of-Sight, I{direction} to the tri-/biaxial (L{Los}, L{Vector3d}),
+       @kwarg los: Line-Of-Sight, I{direction} to the tri-/biaxial (L{Los}, L{Vector3d})
                    or C{True} for the I{normal, perpendicular, plumb} to the surface of
                    the tri-/biaxial or C{False} or C{None} to point to its center.
        @kwarg tri_biax: A triaxial (L{Triaxial}, L{Triaxial_}, L{JacobiConformal} or
@@ -1275,13 +1275,13 @@ def hartzell4(pov, los=False, tri_biax=_WGS84, **name):
         T = tri_biax
     else:
         D = tri_biax if isinstance(tri_biax, Datum) else \
-                  _spherical_datum(tri_biax, name__=hartzell4)  # _DUNDER_nameof
+                  _spherical_datum(tri_biax, name__=hartzell4)  # typename
         T = D.ellipsoid._triaxial
     try:
         v, h, i = _hartzell3(pov, los, T)
     except Exception as x:
         raise TriaxialError(pov=pov, los=los, tri_biax=tri_biax, cause=x)
-    n = _name__(name, name__=hartzell4)  # _DUNDER_nameof
+    n = _name__(name, name__=hartzell4)  # typename
     return Vector4Tuple(v.x, v.y, v.z, h, iteration=i, name=n)
 
 
@@ -1478,19 +1478,18 @@ def _rootNd(r, s, u, v, w, g, eps=EPS0):
     '''
     u *=  r
     v *=  s  # 0 for 2-D root
-    t0 =  w + _N_1_0
-    t1 = _0_0 if g < 0 else (hypot_(u, w, v) + _N_1_0)
+    t0 =  w - _1_0
+    t1 = _0_0 if g < 0 else (hypot_(u, w, v) - _1_0)
     # assert t0 <= t1
-    _e = -eps
-    for i in range(1, _TRIPS):  # 47..65
+    for i in range(1, _TRIPS):  # 48..58
         t = (t1 + t0) * _0_5
         e =  t1 - t0
-        if _e < e < eps or t in (t0, t1):
+        if eps > e > -eps or _isin(t, t0, t1):
             break
         g = fsumf_(_N_1_0,  # ~= _hypot2_1
                    _over02(u, t +  r),
-                   _over02(w, t - _N_1_0),
-                   _over02(v, t +  s) if v else _0_0)
+                   _over02(w, t + _1_0), (
+                   _over02(v, t +  s) if v else _0_0))
         if g > 0:
             t0 = t
         elif g < 0:
@@ -1527,7 +1526,7 @@ def _validate(a, b, c, d, T, x, y, z, val):
                                 dot=e, eps=val)
 
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     from pygeodesy import printf
     from pygeodesy.interns import _COMMA_, _NL_, _NLATvar_
@@ -1540,6 +1539,10 @@ if __name__ == '__main__':
     t = [NN] + Triaxials.toRepr(all=True, asorted=True).split(_NL_)
     printf(_NLATvar_.join(i.strip(_COMMA_) for i in t))
 
+# % python3 -m pygeodesy.triaxials
+#
+# Bektas: height4(x=3909251.554667, y=3909165.750567, z=3170432.501602, h=999.999996)
+
 # **) MIT License
 #
 # Copyright (C) 2022-2025 -- mrJean1 at Gmail -- All Rights Reserved.

pygeodesy/units.py

@@ -6,11 +6,12 @@ basic C{float}, C{int} respectively C{str} to named units as L{Degrees},
 L{Feet}, L{Meter}, L{Radians}, etc.
 '''
 
-from pygeodesy.basics import isscalar, issubclassof, signOf
+from pygeodesy.basics import isscalar, issubclassof, signOf,  typename
 from pygeodesy.constants import EPS, EPS1, PI, PI2, PI_2, _umod_360, _0_0, \
                                _0_001,  _0_5, INT0  # PYCHOK for .mgrs, .namedTuples
 from pygeodesy.dms import F__F, F__F_, S_NUL, S_SEP, parseDMS, parseRad, _toDMS
 from pygeodesy.errors import _AssertionError, TRFError, UnitError, _xattr, _xcallable
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _azimuth_, _band_, _bearing_, _COMMASPACE_, \
                              _degrees_, _degrees2_, _distance_, _E_, _easting_, \
                              _epoch_, _EW_, _feet_, _height_, _lam_, _lat_, _LatLon_, \
@@ -27,7 +28,7 @@ from pygeodesy.unitsBase import Float, Int, _NamedUnit, Radius, Str,  Fmt, fstr
 from math import degrees, isnan, radians
 
 __all__ = _ALL_LAZY.units
-__version__ = '24.11.14'
+__version__ = '25.04.14'
 
 
 class Float_(Float):
@@ -860,8 +861,8 @@ def _std_repr(*Classes):
     '''
     from pygeodesy.internals import _getenv
     for C in Classes:
-        if hasattr(C, _std_repr.__name__):  # PYCHOK del _std_repr
-            env = 'PYGEODESY_%s_STD_REPR' % (C.__name__.upper(),)
+        if hasattr(C, typename(_std_repr)):  # PYCHOK del _std_repr
+            env = 'PYGEODESY_%s_STD_REPR' % (typename(C).upper(),)
             if _getenv(env, _std_).lower() != _std_:
                 C._std_repr = False
 

pygeodesy/unitsBase.py

@@ -4,8 +4,9 @@
 u'''Basic C{Float}, C{Int} and C{Str}ing units classes.
 '''
 
-from pygeodesy.basics import isstr, issubclassof, _xsubclassof
+from pygeodesy.basics import _isin, isstr, issubclassof, _xsubclassof,  typename
 from pygeodesy.errors import _IsnotError, _UnexpectedError, UnitError, _XError
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _degrees_, _degrees2_, _invalid_, _meter_, \
                              _radians_, _radians2_, _radius_, _UNDER_, _units_, \
                              _std_  # PYCHOK used!
@@ -15,7 +16,7 @@ from pygeodesy.named import modulename, _Named,  property_doc_
 from pygeodesy.streprs import Fmt, fstr
 
 __all__ = _ALL_LAZY.unitsBase
-__version__ = '24.08.13'
+__version__ = '25.04.14'
 
 
 class _NamedUnit(_Named):
@@ -49,7 +50,7 @@ class _NamedUnit(_Named):
         elif name:
             pass
         elif name__ is not None:
-            name = name__.__name__
+            name = typename(name__)
         return name, arg
 
     @staticmethod  # PYCHOK unused suffix
@@ -84,7 +85,7 @@ class _NamedUnit(_Named):
     def std_repr(self, std):
         '''Set the representation (C{True} or C{"std"} for standard).
         '''
-        self._std_repr = std in (True, _std_)
+        self._std_repr = _isin(std, True, _std_)
 
     def _toRepr(self, value):
         '''(INTERNAL) Representation "<name> (<value>)" or "<classname>(<value>)".

pygeodesy/ups.py

@@ -28,7 +28,7 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.dms import degDMS, _neg, parseDMS2
 from pygeodesy.errors import RangeError, _ValueError, _xkwds_pop2
 from pygeodesy.fmath import hypot, hypot1, sqrt0
-from pygeodesy.internals import _getPYGEODESY, _under
+from pygeodesy.internals import _envPYGEODESY, _under
 from pygeodesy.interns import NN, _COMMASPACE_, _inside_, _N_, \
                              _pole_, _range_, _S_, _scale0_, \
                              _SPACE_, _std_, _to_, _UTM_
@@ -49,9 +49,9 @@ from pygeodesy.utmupsBase import Fmt, _LLEB, _hemi, _parseUTMUPS5, _to4lldn, \
 from math import fabs, radians, tan  # as _tan
 
 __all__ = _ALL_LAZY.ups
-__version__ = '24.11.26'
+__version__ = '25.04.14'
 
-_BZ_UPS  = _getPYGEODESY('UPS_POLES', _std_) == _std_
+_BZ_UPS  = _envPYGEODESY('UPS_POLES', _std_) == _std_
 _Falsing =  Meter(2000e3)  # false easting and northing (C{meter})
 _K0_UPS  =  Float(_K0_UPS= 0.994)  # scale factor at central meridian
 _K1_UPS  =  Float(_K1_UPS=_1_0)    # rescale point scale factor

pygeodesy/utily.py

@@ -18,7 +18,7 @@ from pygeodesy.constants import EPS, EPS0, INF, NAN, PI, PI2, PI_2, R_M, \
                                _copysign_0_0, _float, _isfinite, isnan, isnear0, \
                                _over, _umod_360, _umod_PI2
 from pygeodesy.errors import _ValueError, _xkwds,  _ALL_LAZY, _MODS
-from pygeodesy.internals import _passargs
+from pygeodesy.internals import _passargs, typename
 from pygeodesy.interns import _edge_, _radians_, _semi_circular_, _SPACE_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .errors
 from pygeodesy.units import Degrees, Degrees_, Feet, Float, Lam, Lamd, \
@@ -28,7 +28,7 @@ from math import acos, asin, atan2 as _atan2, cos, degrees, fabs, radians, \
                  sin, tan as _tan  # pow
 
 __all__ = _ALL_LAZY.utily
-__version__ = '25.01.05'
+__version__ = '25.04.14'
 
 _G_DEG     = _float(  400.0 / _360_0)  # grades per degree
 _G_RAD     = _float(  400.0 /  PI2)    # grades per radian
@@ -1109,7 +1109,7 @@ def unrollPI(rad1, rad2, wrap=True):
 def _valueError(where, x, raiser=True, **kwds):
     '''(INTERNAL) Return a C{_ValueError} or C{None}.
     '''
-    t = _MODS.streprs.Fmt.PAREN(where.__name__, x)
+    t = _MODS.streprs.Fmt.PAREN(typename(where), x)
     return _ValueError(t, **kwds) if raiser else None
 
 
@@ -1193,7 +1193,7 @@ class _Wrap(object):
             lat, lon = ll.latlon
             if fabs(lon) > _180_0 or fabs(lat) > _90_0:
                 _n = self.latlon
-                ll = ll.copy(name=_n.__name__)
+                ll = ll.copy(name=typename(_n))
                 ll.latlon = _n(lat, lon)
         return ll
 

pygeodesy/utmups.py

@@ -14,14 +14,14 @@ A pure Python implementation, partially transcoded from C++ class U{UTMUPS
 <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1UTMUPS.html>}
 by I{Charles Karney}.
 '''
-# from pygeodesy.basics import map1  # from .namedTuples
+from pygeodesy.basics import _isin, map1
 # from pygeodesy.datums import _WGS84  # from .utmupsBase
 from pygeodesy.errors import _IsnotError, RangeError, _ValueError, _xkwds_pop2
 from pygeodesy.interns import NN, _easting_, _MGRS_, _northing_, _NS_, \
                              _outside_, _range_, _SPACE_, _UPS_, _UTM_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import modulename
-from pygeodesy.namedTuples import UtmUps5Tuple, UtmUps8Tuple,  map1
+from pygeodesy.namedTuples import UtmUps5Tuple, UtmUps8Tuple
 # from pygeodesy.streprs import Fmt  # from .utmupsBase
 from pygeodesy.units import Northing, _100km
 from pygeodesy.ups import parseUPS5, toUps8, Ups, UPSError, upsZoneBand5
@@ -31,7 +31,7 @@ from pygeodesy.utmupsBase import Fmt, _to4lldn, _to3zBhp, _UPS_ZONE, \
                                 _UTMUPS_ZONE_MAX, _WGS84
 
 __all__ = _ALL_LAZY.utmups
-__version__ = '24.06.11'
+__version__ = '25.04.14'
 
 _MGRS_TILE = _100km  # in .mgrs.Mgrs.tile
 
@@ -179,7 +179,7 @@ def UtmUps(zone, hemipole, easting, northing, band=NN, datum=_WGS84, falsed=True
              <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1UTMUPS.html>}.
     '''
     z, B, hp = _to3zBhp(zone, band, hemipole=hemipole)
-    U = Ups if z in (_UPS_ZONE, _UPS_ZONE_STR) else Utm
+    U = Ups if _isin(z, _UPS_ZONE, _UPS_ZONE_STR) else Utm
     return U(z, hp, easting, northing, band=B, datum=datum, falsed=falsed, **name)
 
 

pygeodesy/utmupsBase.py

@@ -4,39 +4,44 @@
 u'''(INTERNAL) Private class C{UtmUpsBase}, functions and constants
 for modules L{epsg}, L{etm}, L{mgrs}, L{ups} and L{utm}.
 '''
+# make sure int/int division yields float quotient, see .basics
+from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import isint, isscalar, isstr, neg_, \
-                            _xinstanceof, _xsubclassof
+from pygeodesy.basics import _isin, isint, isscalar, isstr, neg_, \
+                             _xinstanceof, _xsubclassof
 from pygeodesy.constants import _float, _0_0, _0_5, _N_90_0, _180_0
 from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.dms import degDMS, parseDMS2
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB
 from pygeodesy.errors import _or, ParseError, _parseX, _ValueError, \
                              _xattrs, _xkwds, _xkwds_not
+# from pygeodesy.fsums import Fsum  # _MODS
 # from pygeodesy.internals import _name__, _under  # from .named
-from pygeodesy.interns import NN, _A_, _B_, _COMMA_, _Error_, \
-                             _gamma_, _n_a_, _not_, _N_, _NS_, _PLUS_, \
-                             _S_, _scale_, _SPACE_, _Y_, _Z_
+from pygeodesy.interns import NN, _A_, _B_, _COMMA_, _Error_, _gamma_, \
+                             _n_a_, _not_, _N_, _NS_, _PLUS_, _scale_, \
+                             _S_, _SPACE_, _Y_, _Z_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name__, _NamedBase,  _under
 from pygeodesy.namedTuples import EasNor2Tuple, LatLonDatum5Tuple
 from pygeodesy.props import deprecated_method, property_doc_, _update_all, \
                             deprecated_property_RO, Property_RO, property_RO
 from pygeodesy.streprs import Fmt, fstr, _fstrENH2, _xzipairs
-from pygeodesy.units import Band, Easting, Northing, Scalar, Zone
-from pygeodesy.utily import _Wrap, wrap360
+from pygeodesy.units import Band, Easting, Lat, Northing, Phi, Scalar, Zone
+from pygeodesy.utily import atan1, _Wrap, wrap360
+
+from math import cos, degrees, fabs, sin, tan
 
 __all__ = _ALL_LAZY.utmupsBase
-__version__ = '24.08.13'
+__version__ = '25.04.25'
 
 _UPS_BANDS = _A_, _B_, _Y_, _Z_  # UPS polar bands SE, SW, NE, NW
 # _UTM_BANDS = _MODS.utm._Bands
 
-_UTM_LAT_MAX  = _float( 84)          # PYCHOK for export (C{degrees})
-_UTM_LAT_MIN  = _float(-80)          # PYCHOK for export (C{degrees})
+_UTM_LAT_MAX = _float( 84)          # PYCHOK for export (C{degrees})
+_UTM_LAT_MIN = _float(-80)          # PYCHOK for export (C{degrees})
 
-_UPS_LAT_MAX  = _UTM_LAT_MAX - _0_5  # PYCHOK includes 30' UTM overlap
-_UPS_LAT_MIN  = _UTM_LAT_MIN + _0_5  # PYCHOK includes 30' UTM overlap
+_UPS_LAT_MAX = _UTM_LAT_MAX - _0_5  # PYCHOK includes 30' UTM overlap
+_UPS_LAT_MIN = _UTM_LAT_MIN + _0_5  # PYCHOK includes 30' UTM overlap
 
 _UPS_LATS = {_A_: _N_90_0, _Y_: _UTM_LAT_MAX,  # UPS band bottom latitudes,
              _B_: _N_90_0, _Z_: _UTM_LAT_MAX}  # PYCHOK see .Mgrs.bandLatitude
@@ -91,7 +96,7 @@ class UtmUpsBase(_NamedBase):
         if band:
             self._band1(band)
 
-        if datum not in (None, self._datum):
+        if not _isin(datum, None, self._datum):
             self._datum = _ellipsoidal_datum(datum)  # raiser=_datum_, name=band
 
         if not falsed:
@@ -189,6 +194,45 @@ class UtmUpsBase(_NamedBase):
         '''I{Must be overloaded}.'''
         self._notOverloaded(self)
 
+    def _footpoint(self, y, lat0, makris):
+        '''(INTERNAL) Compute to foot-point latitude in C{radians}.
+        '''
+        if y is None:
+            _, y = self.eastingnorthing2(falsed=False)
+        S = _MODS.fsums.Fsum
+        E =  self.datum.ellipsoid
+        P =  S(E.Llat(lat0), y)
+        if E.isSpherical:
+            p = P.fover(E.a)
+        elif makris:
+            r = P.fover(E.b)
+            p = fabs(r)
+            if p:
+                e2 = E.e22  # E.e22abs?
+                e4 = E.e4
+
+                e1  = S(e2 /  4, -11 /  64 * e4, -1).as_iscalar
+                e2  = S(e2 /  8, -13 / 128 * e4)    .as_iscalar
+                e4 *= cos(p)**2 / 8
+
+                s =  sin(p * 2)
+                p = -p
+                U =  S(e1 * p, e2 * s, e4 * p, (5 / 8 * e4) * s**2)
+                p =  atan1(E.a * tan(float(U)) / E.b)
+                if r < 0:  # copysign(p, y)
+                    p = -p
+        else:  # PyGeodetics
+            f  = E.f
+            f2 = f**2
+            f3 = f**3
+            B0 = S(1, -f / 2, f2 / 16, f3 / 32) * E.a
+            r  = P.fover(B0)
+            P  = S(r, S(3 / 4 * f, 3 /  8 * f2, 21 / 256 * f3) * sin(r * 2),
+                      S(          21 / 64 * f2, 21 /  64 * f3) * sin(r * 4),
+                                               151 / 768 * f3  * sin(r * 6))
+            p  = float(P)
+        return p
+
     @Property_RO
     def gamma(self):
         '''Get the meridian convergence (C{degrees}) or C{None}
@@ -204,6 +248,23 @@ class UtmUpsBase(_NamedBase):
             self._toLLEB()
         return self._hemisphere
 
+    def latFootPoint(self, northing=None, lat0=0, makris=False):
+        '''Compute the foot-point latitude in C{degrees}.
+
+           @arg northing: Northing (C{meter}, same units this datum's ellipsoid's axes),
+                          overriding this I{unfalsed} northing.
+           @kwarg lat0: Geodetic latitude of the meridian's origin (C{degrees}).
+           @kwarg makris: If C{True}, use C{Makris}' formula, otherwise C{PyGeodetics}'.
+
+           @return: Foot-point latitude (C{degrees}).
+
+           @see: U{PyGeodetics<https://GitHub.com/paarnes/pygeodetics>}, U{FootpointLatitude
+                 <https://GitHub.com/APRIL-ZJU/clins/blob/master/include/utils/gps_convert_utils.h#L143>},
+                 U{Makris<https://www.TandFonline.com/doi/abs/10.1179/sre.1982.26.205.345>} and
+                 U{Geomatics' Mercator, page 60<https://Geomatics.CC/legacy-files/mercator.pdf>}.
+        '''
+        return Lat(FootPoint=degrees(self._footpoint(northing, lat0, makris)))
+
     def _latlon5(self, LatLon, **LatLon_kwds):
         '''(INTERNAL) Get cached C{._toLLEB} as B{C{LatLon}} instance.
         '''
@@ -255,6 +316,15 @@ class UtmUpsBase(_NamedBase):
         '''
         return self._northing
 
+    def phiFootPoint(self, northing=None, lat0=0, makris=False):
+        '''Compute the foot-point latitude in C{radians}.
+
+           @return: Foot-point latitude (C{radians}).
+
+           @see: Method L{latFootPoint<UtmUpsBase.latFootPoint>} for further details.
+        '''
+        return Phi(FootPoint=self._footpoint(northing, lat0, makris))
+
     @Property_RO
     def scale(self):
         '''Get the grid scale (C{float}) or C{None}.
@@ -302,9 +372,9 @@ class UtmUpsBase(_NamedBase):
            @note: If not specified, the I{latitudinal} C{band} is computed from
                   the (geodetic) latitude and the C{datum}.
         '''
-        return self._mgrs if center in (False, 0, _0_0) else (
-               self._mgrs_lowerleft if center in (True,) else
-              _toMgrs(_lowerleft(self, center)))  # PYCHOK indent
+        return self._mgrs_lowerleft if center is True else (
+              _toMgrs(_lowerleft(self, center)) if center else
+               self._mgrs)  # PYCHOK indent
 
     def _toRepr(self, fmt, B, cs, prec, sep):  # PYCHOK expected
         '''(INTERNAL) Return a representation for this ETM/UTM/UPS coordinate.
@@ -349,8 +419,8 @@ def _lowerleft(utmups, center):  # in .ellipsoidalBase._lowerleft
             t = c * 2
             e = int(utmups.easting  % t)
             n = int(utmups.northing % t)
-            if (e == c and n in (c, c - 1)) or \
-               (n == c and e in (c, c - 1)):
+            if (e == c and _isin(n, c, c - 1)) or \
+               (n == c and _isin(e, c, c - 1)):
                 break
         else:
             return utmups  # unchanged