pygeodesy 24.10.10__py2.py3-none-any.whl → 24.11.11__py2.py3-none-any.whl

pygeodesy/sphericalTrigonometry.py

@@ -10,7 +10,7 @@ L{perimeterOf}, I{all spherical}.
 
 Pure Python implementation of geodetic (lat-/longitude) methods using
 spherical trigonometry, transcoded from JavaScript originals by
-I{(C) Chris Veness 2011-2016} published under the same MIT Licence**, see
+I{(C) Chris Veness 2011-2024} published under the same MIT Licence**, see
 U{Latitude/Longitude<https://www.Movable-Type.co.UK/scripts/latlong.html>}.
 '''
 # make sure int/int division yields float quotient, see .basics
@@ -24,7 +24,7 @@ from pygeodesy.datums import _ellipsoidal_datum, _mean_radius
 from pygeodesy.errors import _AssertionError, CrossError, crosserrors, \
                              _TypeError, _ValueError, IntersectionError, \
                              _xError, _xkwds, _xkwds_get, _xkwds_pop2
-from pygeodesy.fmath import favg, fdot, fmean, hypot
+from pygeodesy.fmath import favg, fdot, fdot_, fmean, hypot
 from pygeodesy.fsums import Fsum, fsum, fsumf_
 from pygeodesy.formy import antipode_, bearing_, _bearingTo2, excessAbc_, \
                             excessGirard_, excessLHuilier_, opposing_, _radical2, \
@@ -54,7 +54,7 @@ from pygeodesy.vector3d import sumOf, Vector3d
 from math import asin, atan2, cos, degrees, fabs, radians, sin
 
 __all__ = _ALL_LAZY.sphericalTrigonometry
-__version__ = '24.09.23'
+__version__ = '24.11.07'
 
 _PI_EPS4 = PI - EPS4
 if _PI_EPS4 >= PI:
@@ -182,8 +182,8 @@ class LatLon(LatLonSphericalBase):
         return degrees180(m - d), degrees180(m + d)
 
     def crossTrackDistanceTo(self, start, end, radius=R_M, wrap=False):
-        '''Compute the (signed) distance from this point to
-           the great circle defined by a start and an end point.
+        '''Compute the (signed) distance from this point to a great
+           circle from a start to an end point.
 
            @arg start: Start point of the great circle line (L{LatLon}).
            @arg end: End point of the great circle line (L{LatLon}).
@@ -205,7 +205,7 @@ class LatLon(LatLonSphericalBase):
 
     def destination(self, distance, bearing, radius=R_M, height=None):
         '''Locate the destination from this point after having
-           travelled the given distance on the given initial bearing.
+           travelled the given distance on a bearing from North.
 
            @arg distance: Distance travelled (C{meter}, same units as
                           B{C{radius}}).
@@ -253,7 +253,7 @@ class LatLon(LatLonSphericalBase):
 
     def greatCircle(self, bearing, Vector=Vector3d, **Vector_kwds):
         '''Compute the vector normal to great circle obtained by heading
-           on the given initial bearing from this point.
+           from this point on the bearing from North.
 
            Direction of vector is such that initial bearing vector
            b = c × n, where n is an n-vector representing this point.
@@ -271,8 +271,9 @@ class LatLon(LatLonSphericalBase):
         a, b = self.philam
         sa, ca, sb, cb, st, ct = sincos2_(a, b, Bearing_(bearing))
 
-        return Vector(sb * ct - cb * sa * st,
-                     -cb * ct - sb * sa * st,
+        sa *= st
+        return Vector(fdot_(sb, ct, -cb, sa),
+                     -fdot_(cb, ct,  sb, sa),
                       ca * st, **Vector_kwds)  # XXX .unit()?
 
     def initialBearingTo(self, other, wrap=False, raiser=False):
@@ -341,9 +342,9 @@ class LatLon(LatLonSphericalBase):
                     a = sin(r - t)  # / sr  superflous
                     b = sin(    t)  # / sr  superflous
 
-                    x = a * ca1 * cb1 + b * ca2 * cb2
-                    y = a * ca1 * sb1 + b * ca2 * sb2
-                    z = a * sa1       + b * sa2
+                    x = fdot_(a, ca1 * cb1, b, ca2 * cb2)
+                    y = fdot_(a, ca1 * sb1, b, ca2 * sb2)
+                    z = fdot_(a, sa1,       b, sa2)
 
                     a = atan1d(z, hypot(x, y))
                     b = atan2d(y, x)
@@ -358,7 +359,7 @@ class LatLon(LatLonSphericalBase):
 
     def intersection(self, end1, other, end2, height=None, wrap=False):
         '''Compute the intersection point of two lines, each defined by
-           two points or a start point and bearing from North.
+           two points or a start point and a bearing from North.
 
            @arg end1: End point of this line (L{LatLon}) or the initial
                       bearing at this point (compass C{degrees360}).
@@ -395,7 +396,7 @@ class LatLon(LatLonSphericalBase):
     def intersections2(self, rad1, other, rad2, radius=R_M, eps=_0_0,
                                                 height=None, wrap=True):
         '''Compute the intersection points of two circles, each defined
-           by a center point and radius.
+           by a center point and a radius.
 
            @arg rad1: Radius of the this circle (C{meter} or C{radians},
                       see B{C{radius}}).
@@ -536,7 +537,7 @@ class LatLon(LatLonSphericalBase):
         return r
 
     def nearestOn(self, point1, point2, radius=R_M, **wrap_adjust_limit):
-        '''Locate the point between two points closest to this point.
+        '''Locate the point between two other points closest to this point.
 
            Distances are approximated by function L{pygeodesy.equirectangular4},
            subject to the supplied B{C{options}}.
@@ -679,8 +680,8 @@ class LatLon(LatLonSphericalBase):
         return self._xnamed(_t7Tuple(t, radius))
 
     def triangulate(self, bearing1, other, bearing2, **height_wrap):
-        '''Locate a point given this, an other point and the (initial) bearing
-           at this and at the other point.
+        '''Locate a point given this, an other point and a bearing from
+           North at both points.
 
            @arg bearing1: Bearing at this point (compass C{degrees360}).
            @arg other: The other point (C{LatLon}).
@@ -755,8 +756,8 @@ _T00 = LatLon(0, 0, name='T00')  # reference instance (L{LatLon})
 
 
 def areaOf(points, radius=R_M, wrap=False):  # was=True
-    '''Calculate the area of a (spherical) polygon or composite
-       (with the pointsjoined by great circle arcs).
+    '''Calculate the area of a (spherical) polygon or composite (with the
+       points joined by great circle arcs).
 
        @arg points: The polygon points or clips (L{LatLon}[], L{BooleanFHP}
                     or L{BooleanGH}).
@@ -868,8 +869,8 @@ def _int3d2(s, end, wrap, _i_, Vector, hs):
                                     -(b1 + b2) * _0_5)
     cb21 *= sin(a1 - a2)  # sa21
     sb21 *= sin(a1 + a2)  # sa12
-    x = Vector(sb12 * cb21 - cb12 * sb21,
-               cb12 * cb21 + sb12 * sb21,
+    x = Vector(fdot_(sb12, cb21, -cb12, sb21),
+               fdot_(cb12, cb21,  sb12, sb21),
                cos(a1) * cos(a2) * sin(db))  # ll=start
     return x.unit(), (db, (a2 - a1))  # negated d
 
@@ -882,16 +883,17 @@ def _intdot(ds, a1, b1, a, b, wrap):
 
 def intersecant2(center, circle, point, other, **radius_exact_height_wrap):
     '''Compute the intersections of a circle and a (great circle) line given as
-       two points or as a point and bearing.
+       two points or as a point and a bearing from North.
 
        @arg center: Center of the circle (L{LatLon}).
-       @arg circle: Radius of the circle (C{meter}, same units as B{C{radius}})
-                    or a point on the circle (L{LatLon}).
+       @arg circle: Radius of the circle (C{meter}, same units as the earth
+                    B{C{radius}}) or a point on the circle (L{LatLon}).
        @arg point: A point on the (great circle) line (L{LatLon}).
        @arg other: An other point on the (great circle) line (L{LatLon}) or
                    the bearing at the B{C{point}} (compass C{degrees360}).
-       @kwarg radius_exact_height_wrap: Optional keyword arguments, see
-                     method L{LatLon.intersecant2} for further details.
+       @kwarg radius_exact_height_wrap: Optional keyword arguments, see method
+                     L{intersecant2<pygeodesy.sphericalBase.LatLonSphericalBase.
+                     intersecant2>} for further details.
 
        @return: 2-Tuple of the intersection points (representing a chord), each
                 an instance of the B{C{point}} class.  Both points are the same
@@ -899,8 +901,8 @@ def intersecant2(center, circle, point, other, **radius_exact_height_wrap):
 
        @raise IntersectionError: The circle and line do not intersect.
 
-       @raise TypeError: If B{C{center}} or B{C{point}} not L{LatLon} or
-                         B{C{circle}} or B{C{other}} invalid.
+       @raise TypeError: If B{C{center}}, B{C{point}}, B{C{circle}} or B{C{other}}
+                         not L{LatLon}.
 
        @raise UnitError: Invalid B{C{circle}}, B{C{other}}, B{C{radius}},
                          B{C{exact}}, B{C{height}} or B{C{napieradius}}.
@@ -915,7 +917,7 @@ def intersecant2(center, circle, point, other, **radius_exact_height_wrap):
 
 
 def _intersect(start1, end1, start2, end2, height=None, wrap=False,  # in.ellipsoidalBaseDI._intersect3
-                                           LatLon=None, **LatLon_kwds):
+                                           LatLon=LatLon, **LatLon_kwds):
     # (INTERNAL) Intersect two (spherical) lines, see L{intersection}
     # above, separated to allow callers to embellish any exceptions
 
@@ -983,75 +985,68 @@ def _intersect(start1, end1, start2, end2, height=None, wrap=False,  # in.ellips
 
 
 def intersection(start1, end1, start2, end2, height=None, wrap=False,
-                                             LatLon=LatLon, **LatLon_kwds):
-    '''Compute the intersection point of two lines, each defined
-       by two points or a start point and bearing from North.
+                                             **LatLon_and_kwds):
+    '''Compute the intersection point of two lines, each defined by
+       two points or by a start point and a bearing from North.
 
        @arg start1: Start point of the first line (L{LatLon}).
-       @arg end1: End point of the first line (L{LatLon}) or
-                  the initial bearing at the first start point
-                  (compass C{degrees360}).
+       @arg end1: End point of the first line (L{LatLon}) or the bearing
+                  at the first start point (compass C{degrees360}).
        @arg start2: Start point of the second line (L{LatLon}).
-       @arg end2: End point of the second line (L{LatLon}) or
-                  the initial bearing at the second start point
-                  (compass C{degrees360}).
+       @arg end2: End point of the second line (L{LatLon}) or the bearing
+                  at the second start point (compass C{degrees360}).
        @kwarg height: Optional height for the intersection point,
                       overriding the mean height (C{meter}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
-                    B{C{start2}} and both B{C{end*}} points (C{bool}).
-       @kwarg LatLon: Optional class to return the intersection
-                      point (L{LatLon}) or C{None}.
-       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                           arguments, ignored if C{B{LatLon} is None}.
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{start2}}
+                    and both B{C{end*}} points (C{bool}).
+       @kwarg LatLon_and_kwds: Optional class C{B{LatLon}=}L{LatLon} to use
+                     for the intersection point and optionally additional
+                     B{C{LatLon}} keyword arguments, ignored if C{B{LatLon}
+                     is None}.
 
-       @return: The intersection point as a (B{C{LatLon}}) or if
-                C{B{LatLon} is None} a L{LatLon3Tuple}C{(lat, lon,
-                height)}.  An alternate intersection point might
-                be the L{antipode} to the returned result.
+       @return: The intersection point as a (B{C{LatLon}}) or if C{B{LatLon}
+                is None} a L{LatLon3Tuple}C{(lat, lon, height)}.  An alternate
+                intersection point might be the L{antipode} to the returned result.
 
-       @raise IntersectionError: Ambiguous or infinite intersection
-                                 or colinear, parallel or otherwise
-                                 non-intersecting lines.
+       @raise IntersectionError: Ambiguous or infinite intersection or colinear,
+                                 parallel or otherwise non-intersecting lines.
 
-       @raise TypeError: A B{C{start1}}, B{C{end1}}, B{C{start2}}
-                         or B{C{end2}} point not L{LatLon}.
+       @raise TypeError: A B{C{start1}}, B{C{end1}}, B{C{start2}} or B{C{end2}}
+                         point not L{LatLon}.
 
        @raise ValueError: Invalid B{C{height}} or C{null} line.
     '''
     s1 = _T00.others(start1=start1)
     s2 = _T00.others(start2=start2)
     try:
-        return _intersect(s1, end1, s2, end2, height=height, wrap=wrap,
-                                              LatLon=LatLon, **LatLon_kwds)
+        return _intersect(s1, end1, s2, end2, height=height, wrap=wrap, **LatLon_and_kwds)
     except (TypeError, ValueError) as x:
         raise _xError(x, start1=start1, end1=end1, start2=start2, end2=end2)
 
 
 def intersections2(center1, rad1, center2, rad2, radius=R_M, eps=_0_0,
                                                  height=None, wrap=False,  # was=True
-                                                 LatLon=LatLon, **LatLon_kwds):
-    '''Compute the intersection points of two circles each defined
-       by a center point and a radius.
+                                               **LatLon_and_kwds):
+    '''Compute the intersection points of two circles each defined by a
+       center point and a radius.
 
        @arg center1: Center of the first circle (L{LatLon}).
-       @arg rad1: Radius of the first circle (C{meter} or C{radians},
-                  see B{C{radius}}).
+       @arg rad1: Radius of the first circle (C{meter} or C{radians}, see
+                  B{C{radius}}).
        @arg center2: Center of the second circle (L{LatLon}).
-       @arg rad2: Radius of the second circle (C{meter} or C{radians},
-                  see B{C{radius}}).
+       @arg rad2: Radius of the second circle (C{meter} or C{radians}, see
+                  B{C{radius}}).
        @kwarg radius: Mean earth radius (C{meter} or C{None} if B{C{rad1}},
                       B{C{rad2}} and B{C{eps}} are given in C{radians}).
-       @kwarg eps: Required overlap (C{meter} or C{radians}, see
-                   B{C{radius}}).
+       @kwarg eps: Required overlap (C{meter} or C{radians}, see B{C{radius}}).
        @kwarg height: Optional height for the intersection points (C{meter},
                       conventionally) or C{None} for the I{"radical height"}
                       at the I{radical line} between both centers.
        @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{center2}}
                     (C{bool}).
-       @kwarg LatLon: Optional class to return the intersection
-                      points (L{LatLon}) or C{None}.
-       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                           arguments, ignored if C{B{LatLon} is None}.
+       @kwarg LatLon_and_kwds: Optional class C{B{LatLon}=}L{LatLon} to use for
+                     the intersection points and optionally additional B{C{LatLon}}
+                     keyword arguments, ignored if C{B{LatLon} is None}.
 
        @return: 2-Tuple of the intersection points, each a B{C{LatLon}}
                 instance or if C{B{LatLon} is None} a L{LatLon3Tuple}C{(lat,
@@ -1076,7 +1071,7 @@ def intersections2(center1, rad1, center2, rad2, radius=R_M, eps=_0_0,
     try:
         return _intersects2(c1, rad1, c2, rad2, radius=radius, eps=eps,
                                                 height=height, wrap=wrap,
-                                                LatLon=LatLon, **LatLon_kwds)
+                                              **LatLon_and_kwds)
     except (TypeError, ValueError) as x:
         raise _xError(x, center1=center1, rad1=rad1,
                          center2=center2, rad2=rad2, wrap=wrap)
@@ -1225,7 +1220,7 @@ def nearestOn3(point, points, closed=False, radius=R_M, wrap=False, adjust=True,
                      (C{degrees}), default C{9 degrees} is about C{1,000 Km} (for
                      (mean spherical earth radius L{R_KM}).
        @kwarg LatLon_and_kwds: Optional class C{B{LatLon}=L{LatLon}} to return the
-                     closest point and optional, additional C{B{LatLon}} keyword
+                     closest point and optionally additional C{B{LatLon}} keyword
                      arguments or specify C{B{LatLon}=None}.
 
        @return: A L{NearestOn3Tuple}C{(closest, distance, angle)} with the
@@ -1330,9 +1325,9 @@ def triangle7(latA, lonA, latB, lonB, latC, lonC, radius=R_M,
                 C{a}, C{b} and C{c} all in C{degrees} and C{area}
                 in I{square} C{meter} or same units as B{C{radius}}
                 I{squared} or if C{B{radius}=0} or C{None}, a
-                L{Triangle8Tuple}C{(A, a, B, b, C, c, D, E)} all in
-                C{radians} with the I{spherical excess} C{E} as the
-                C{unit area} in C{radians}.
+                L{Triangle8Tuple}C{(A, a, B, b, C, c, D, E)} with
+                I{spherical deficit} C{D} and I{spherical excess}
+                C{E} as the C{unit area}, all in C{radians}.
     '''
     t = triangle8_(Phid(latA=latA), Lamd(lonA=lonA),
                    Phid(latB=latB), Lamd(lonB=lonB),

pygeodesy/streprs.py

@@ -9,7 +9,7 @@ from pygeodesy.basics import isint, islistuple, isscalar, isstr, itemsorted, \
 # from pygeodesy.constants import _0_0
 from pygeodesy.errors import _or, _IsnotError, _TypeError, _ValueError, \
                              _xkwds_get, _xkwds_item2
-# from pygeodesy.internals import _dunder_nameof  # from .lazily
+from pygeodesy.internals import _DUNDER_nameof
 from pygeodesy.interns import NN, _0_, _0to9_, MISSING, _BAR_, _COMMASPACE_, \
                              _DOT_, _E_, _ELLIPSIS_, _EQUAL_, _H_, _LR_PAIRS, \
                              _N_, _name_, _not_scalar_, _PERCENT_, _SPACE_, \
@@ -17,12 +17,12 @@ from pygeodesy.interns import NN, _0_, _0to9_, MISSING, _BAR_, _COMMASPACE_, \
 from pygeodesy.interns import _convergence_, _distant_, _e_, _eps_, _exceeds_, \
                               _EQUALSPACED_, _f_, _F_, _g_, _limit_, _no_, \
                               _tolerance_  # PYCHOK used!
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS,  _dunder_nameof
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 
 from math import fabs, log10 as _log10
 
 __all__ = _ALL_LAZY.streprs
-__version__ = '24.10.04'
+__version__ = '24.10.14'
 
 _at_        = 'at'         # PYCHOK used!
 _EN_PREC    =  6           # max MGRS/OSGR precision, 1 micrometer
@@ -557,14 +557,14 @@ def unstr(where, *args, **kwds_):
         t  =  reprs(args, fmt=g) if args else ()
     if kwds:
         t += pairs(itemsorted(kwds), fmt=g)
-    n = where if isstr(where) else _dunder_nameof(where)  # _NN_
+    n = where if isstr(where) else _DUNDER_nameof(where)  # _NN_
     if C and hasattr(C, n):
         try:  # bound method of class C?
             where = where.__func__
         except AttributeError:
             pass  # method of C?
         if getattr(C, n, None) is where:
-            n = _DOT_(_dunder_nameof(C), n)
+            n = _DOT_(_DUNDER_nameof(C), n)
     return Fmt.PAREN(n, _COMMASPACE_.join(t))
 
 

pygeodesy/trf.py

@@ -5,7 +5,7 @@ u'''I{Veness}' Terrestrial Reference Frames (TRF).
 
 Classes L{RefFrame}, registry L{RefFrames} and L{TRFError}.
 
-Transcoded from I{Chris Veness'} (C) 2006-2022 JavaScript originals U{latlon-ellipsoidal-referenceframe.js
+Transcoded from I{Chris Veness'} (C) 2006-2024 JavaScript originals U{latlon-ellipsoidal-referenceframe.js
 <https://GitHub.com/ChrisVeness/geodesy/blob/master/latlon-ellipsoidal-referenceframe.js>} and
 U{latlon-ellipsoidal-referenceframe-txparams.js
 <https://GitHub.com/ChrisVeness/geodesy/blob/master/latlon-ellipsoidal-referenceframe-txparams.js>}.
@@ -91,7 +91,7 @@ from math import ceil as _ceil, fabs
 # import operator as _operator  # from .datums
 
 __all__ = _ALL_LAZY.trf
-__version__ = '24.06.09'
+__version__ = '24.10.14'
 
 _EP0CH    =  Epoch(0, low=0)
 _Es       = {_EP0CH: _EP0CH}  # L{Epoch}s, deleted below
@@ -391,7 +391,9 @@ class TransformXform(Transform):
            @return: Inverse (L{TransformXform}), unregistered.
         '''
         r = Transform.inverse(self, **name)
-        r._Xform = r.Xform.inverse()
+        X = self.Xform
+        if X:  # unregistered
+            r._Xform = X.inverse()
         return r
 
     def rename(self, name=NN):
@@ -1778,7 +1780,7 @@ if __name__ == '__main__':
                 raise AssertionError(_SPACE_(n, _vs_, t))
 
     _main()
-    del _main
+#   del _main
 
 # **) MIT License
 #

pygeodesy/triaxials.py

@@ -30,14 +30,14 @@ see the U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import isLatLon, isscalar, _ValueError
+from pygeodesy.basics import isLatLon, isscalar
 from pygeodesy.constants import EPS, EPS0, EPS02, EPS4, INT0, PI2, PI_3, PI4, \
-                               _EPS2e4, float0_, isfinite, isnear1, _over, \
+                               _EPS2e4, _SQRT2_2, float0_, isfinite, isnear1, _over, \
                                _0_0, _0_5, _1_0, _N_1_0, _64_0,  _4_0  # PYCHOK used!
 from pygeodesy.datums import Datum, _spherical_datum, _WGS84,  Ellipsoid, _EWGS84, Fmt
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
 # from pygeodesy.elliptic import Elliptic  # _MODS
-# from pygeodesy.errors import _ValueError  # from .basics
+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_, \
@@ -59,7 +59,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d,  _ALL_LAZY, _MODS
 from math import atan2, fabs, sqrt
 
 __all__ = _ALL_LAZY.triaxials
-__version__ = '24.08.26'
+__version__ = '24.10.15'
 
 _not_ordered_ = _not_('ordered')
 _omega_       = 'omega'
@@ -1272,13 +1272,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)  # _DUNDER_nameof
         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)
-    return Vector4Tuple(v.x, v.y, v.z, h, iteration=i,  # _dunder_nameof
+    return Vector4Tuple(v.x, v.y, v.z, h, iteration=i,  # _DUNDER_nameof
                                           name=_name__(name, name__=hartzell4))
 
 
@@ -1308,12 +1308,49 @@ def _over02(p, q):
     return (p / q)**2 if p and q else _0_0
 
 
+def _plumbTo3(px, py, E, eps=EPS):  # in .ellipsoids.Ellipsoid.height4
+    '''(INTERNAL) Nearest point on a 2-D ellipse in 1st quadrant.
+    '''
+    a, b = E.a, E.b
+    if min(px, py, a, b) < EPS0:
+        raise _AssertionError(px=px, py=py, a=a, b=b, E=E)
+
+    a2 = a - b * E.b_a
+    b2 = b - a * E.a_b
+    tx = ty = _SQRT2_2
+    for i in range(16):  # max 5
+        ex = a2 * tx**3
+        ey = b2 * ty**3
+
+        qx = px - ex
+        qy = py - ey
+        q  = hypot(qx, qy)
+        if q < EPS0:  # PYCHOK no cover
+            break
+        r = hypot(ex - tx * a,
+                  ey - ty * b) / q
+
+        sx, tx = tx, min(_1_0, max(0, (ex + qx * r) / a))
+        sy, ty = ty, min(_1_0, max(0, (ey + qy * r) / b))
+        t = hypot(ty, tx)
+        if t < EPS0:  # PYCHOK no cover
+            break
+        tx = tx / t  # /= chokes PyChecker
+        ty = ty / t
+        if fabs(sx - tx) < eps and \
+           fabs(sy - ty) < eps:
+            break
+
+    tx *= a / px
+    ty *= b / py
+    return tx, ty, i  # x and y as fractions
+
+
 def _plumbTo4(x, y, a, b, eps=EPS):
     '''(INTERNAL) Nearest point on and distance to a 2-D ellipse, I{unordered}.
 
-       @see: Function C{pygeodesy.ellipsoids._plumbTo3} and I{Eberly}'s U{Distance
-             from a Point to ... an Ellipse ...<https://www.GeometricTools.com/
-             Documentation/DistancePointEllipseEllipsoid.pdf>}.
+       @see: Function C{_plumbTo3} and I{Eberly}'s U{Distance from a Point to ... an Ellipse ...
+             <https://www.GeometricTools.com/Documentation/DistancePointEllipseEllipsoid.pdf>}.
     '''
     if b > a:
         b, a, d, i = _plumbTo4(y, x, b, a, eps=eps)

pygeodesy/units.py

@@ -18,7 +18,7 @@ from pygeodesy.interns import NN, _azimuth_, _band_, _bearing_, _COMMASPACE_, \
                              _NS_, _NSEW_, _number_, _PERCENT_, _phi_, _precision_, \
                              _radians_, _radians2_, _radius_, _S_, _scalar_, \
                              _units_, _W_, _zone_,  _std_  # PYCHOK used!
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.named import _name__  # _MODS
 from pygeodesy.props import Property_RO
 # from pygeodesy.streprs import Fmt, fstr  # from .unitsBase
@@ -27,7 +27,7 @@ from pygeodesy.unitsBase import Float, Int, _NamedUnit, Radius, Str,  Fmt, fstr
 from math import degrees, isnan, radians
 
 __all__ = _ALL_LAZY.units
-__version__ = '24.08.13'
+__version__ = '24.11.06'
 
 
 class Float_(Float):
@@ -527,7 +527,7 @@ class FIx(Float_):
                         (C{bool}) or C{None} for backward compatible L{LatLon2Tuple} or
                         B{C{LatLon}} with I{averaged} lat- and longitudes.
            @kwarg LatLon_or_Vector_and_kwds: Optional C{B{LatLon}=None} I{or} C{B{Vector}=None}
-                         to return the I{intermediate}, I{fractional} point and optional,
+                         to return the I{intermediate}, I{fractional} point and optionally,
                          additional B{C{LatLon}} I{or} B{C{Vector}} keyword arguments, see
                          function L{fractional<pygeodesy.points.fractional>}.
 
@@ -858,13 +858,14 @@ def _xlimits(arg, low, high, g=False):
 def _std_repr(*Classes):
     '''(INTERNAL) Use standard C{repr} or named C{toRepr}.
     '''
+    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 _getenv(env, _std_).lower() != _std_:
                 C._std_repr = False
 
-_std_repr(Azimuth, Bearing, Bool, Degrees, Float, Int, Meter, Radians, Str)  # PYCHOK expected
+_std_repr(Azimuth, Bearing, Bool, Degrees, Epoch, Float, Int, Meter, Radians, Str)  # PYCHOK expected
 del _std_repr
 
 __all__ += _ALL_DOCS(_NamedUnit)

pygeodesy/ups.py

@@ -28,12 +28,12 @@ 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 _under  # from .named
+from pygeodesy.internals import _getPYGEODESY, _under
 from pygeodesy.interns import NN, _COMMASPACE_, _inside_, _N_, \
                              _pole_, _range_, _S_, _scale0_, \
                              _SPACE_, _std_, _to_, _UTM_
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS,  _getenv
-from pygeodesy.named import nameof,  _under
+# from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
+from pygeodesy.named import nameof,  _ALL_LAZY, _MODS
 from pygeodesy.namedTuples import EasNor2Tuple, UtmUps5Tuple, \
                                   UtmUps8Tuple, UtmUpsLatLon5Tuple
 from pygeodesy.props import deprecated_method, property_doc_, \
@@ -49,9 +49,9 @@ from pygeodesy.utmupsBase import Fmt, _LLEB, _hemi, _parseUTMUPS5, _to4lldn, \
 from math import atan2, fabs, radians, tan
 
 __all__ = _ALL_LAZY.ups
-__version__ = '24.06.11'
+__version__ = '24.10.14'
 
-_BZ_UPS  = _getenv('PYGEODESY_UPS_POLES', _std_) == _std_
+_BZ_UPS  = _getPYGEODESY('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
@@ -229,7 +229,7 @@ class Ups(UtmUpsBase):
 
         r = hypot(x, y)
         t = (r * E.es_c / (self.scale0 * E.a * _2_0)) if r > 0 else EPS0
-        t = E.es_tauf((_1_0 / t - t) * _0_5)
+        t = E.es_tauf(_0_5 / t - _0_5 * t)
         a = atan1d(t)
         if self._pole == _N_:
             b, g    = atan2(x, -y), 1

pygeodesy/utily.py

@@ -3,7 +3,7 @@
 
 u'''Various utility functions.
 
-After I{(C) Chris Veness 2011-2015} published under the same MIT Licence**, see
+After I{(C) Chris Veness 2011-2024} published under the same MIT Licence**, see
 U{Latitude/Longitude<https://www.Movable-Type.co.UK/scripts/latlong.html>} and
 U{Vector-based geodesy<https://www.Movable-Type.co.UK/scripts/latlong-vectors.html>}.
 '''
@@ -27,7 +27,7 @@ from pygeodesy.units import Degrees, Degrees_, Feet, Float, Lam, Lamd, \
 from math import acos, asin, atan2, cos, degrees, fabs, radians, sin, tan  # pow
 
 __all__ = _ALL_LAZY.utily
-__version__ = '24.06.15'
+__version__ = '24.10.12'
 
 # read constant name "_M_Unit" as "meter per Unit"
 _M_CHAIN     = _F(  20.1168)     # yard2m(1) * 22

pygeodesy/utm.py

@@ -8,7 +8,7 @@ L{utmZoneBand5}.
 
 Pure Python implementation of UTM / WGS-84 conversion functions using
 an ellipsoidal earth model, transcoded from JavaScript originals by
-I{(C) Chris Veness 2011-2016} published under the same MIT Licence**, see
+I{(C) Chris Veness 2011-2024} published under the same MIT Licence**, see
 U{UTM<https://www.Movable-Type.co.UK/scripts/latlong-utm-mgrs.html>} and
 U{Module utm<https://www.Movable-Type.co.UK/scripts/geodesy/docs/module-utm.html>}.
 
@@ -39,7 +39,7 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  _under
 from pygeodesy.dms import degDMS, parseDMS2
 from pygeodesy.errors import MGRSError, RangeError, _ValueError, \
                             _xkwds_get, _xkwds_pop2
-from pygeodesy.fmath import fdot3, hypot, hypot1,  _operator
+from pygeodesy.fmath import fdot_, fdot3, hypot, hypot1,  _operator
 # from pygeodesy.internals import _under  # from .datums
 from pygeodesy.interns import MISSING, NN, _by_, _COMMASPACE_, _N_, \
                              _NS_, _outside_, _range_, _S_, _scale0_, \
@@ -63,7 +63,7 @@ from math import asinh, atanh, atan2, cos, cosh, degrees, fabs, \
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.utm
-__version__ = '24.06.11'
+__version__ = '24.11.07'
 
 _Bands = 'CDEFGHJKLMNPQRSTUVWXX'  # UTM latitude bands C..X (no
 # I|O) 8° each, covering 80°S to 84°N and X repeated for 80-84°N
@@ -566,12 +566,12 @@ def toUtm8(latlon, lon=None, datum=None, Utm=Utm, falsed=True,
     # easting, northing: Karney 2011 Eq 7-14, 29, 35
     sb, cb = sincos2(b)
 
-    T = tan(a)
+    T   = tan(a)
     T12 = hypot1(T)
-    S = sinh(E.e * atanh(E.e * T / T12))
+    S   = sinh(E.e * atanh(E.e * T / T12))
 
-    T_ = T * hypot1(S) - S * T12
-    H = hypot(T_, cb)
+    T_ = fdot_(T, hypot1(S), -S, T12)
+    H  = hypot(T_, cb)
 
     y = atan2(T_, cb)  # ξ' ksi
     x = asinh(sb / H)  # η' eta