pygeodesy 24.10.24__py2.py3-none-any.whl → 24.12.12__py2.py3-none-any.whl

pygeodesy/sphericalTrigonometry.py

@@ -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, \
@@ -46,15 +46,16 @@ from pygeodesy.sphericalBase import _m2radians, CartesianSphericalBase, \
 # from pygeodesy.streprs import Fmt as _Fmt  # from .points XXX shadowed
 from pygeodesy.units import Bearing_, Height, _isDegrees, _isRadius, Lamd, \
                               Phid, Radius_, Scalar
-from pygeodesy.utily import acos1, asin1, atan1d, atan2d, degrees90, degrees180, \
-                            degrees2m, m2radians, radiansPI2, sincos2_, tan_2, \
-                            unrollPI, _unrollon, _unrollon3, _Wrap, wrap180, wrapPI
+from pygeodesy.utily import acos1, asin1, atan1d, atan2, atan2d, degrees90, \
+                            degrees180, degrees2m, m2radians, radiansPI2, \
+                            sincos2_, tan_2, unrollPI, _unrollon, _unrollon3, \
+                            wrap180, wrapPI, _Wrap
 from pygeodesy.vector3d import sumOf, Vector3d
 
-from math import asin, atan2, cos, degrees, fabs, radians, sin
+from math import asin, cos, degrees, fabs, radians, sin
 
 __all__ = _ALL_LAZY.sphericalTrigonometry
-__version__ = '24.10.12'
+__version__ = '24.11.24'
 
 _PI_EPS4 = PI - EPS4
 if _PI_EPS4 >= PI:
@@ -182,8 +183,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 +206,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 +254,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 +272,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 +343,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 +360,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 +397,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 +538,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 +681,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 +757,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 +870,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,7 +884,7 @@ 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 the earth
@@ -916,7 +918,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
 
@@ -984,75 +986,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,
@@ -1077,7 +1072,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)
@@ -1226,7 +1221,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
@@ -1331,9 +1326,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),
@@ -1415,7 +1410,7 @@ __all__ += _ALL_OTHER(Cartesian, LatLon,  # classes
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/streprs.py

@@ -14,19 +14,20 @@ from pygeodesy.interns import NN, _0_, _0to9_, MISSING, _BAR_, _COMMASPACE_, \
                              _DOT_, _E_, _ELLIPSIS_, _EQUAL_, _H_, _LR_PAIRS, \
                              _N_, _name_, _not_scalar_, _PERCENT_, _SPACE_, \
                              _STAR_, _UNDER_
-from pygeodesy.interns import _convergence_, _distant_, _e_, _eps_, _exceeds_, \
-                              _EQUALSPACED_, _f_, _F_, _g_, _limit_, _no_, \
-                              _tolerance_  # PYCHOK used!
+from pygeodesy.interns import _convergence_, _distant_, _e_, _exceeds_, \
+                              _EQUALSPACED_, _f_, _F_, _g_, _limit_, \
+                              _no_, _tolerance_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 
 from math import fabs, log10 as _log10
 
 __all__ = _ALL_LAZY.streprs
-__version__ = '24.10.14'
+__version__ = '24.11.26'
 
 _at_        = 'at'         # PYCHOK used!
 _EN_PREC    =  6           # max MGRS/OSGR precision, 1 micrometer
 _EN_WIDE    =  5           # number of MGRS/OSGR units, log10(_100km)
+_eps_       = 'eps'        # PYCHOK used!
 _OKd_       = '._-'        # acceptable name characters
 _PAREN_g    = '(%g)'       # PYCHOK used!
 _RESIDUAL_  = 'RESIDUAL'   # PYCHOK used!
@@ -191,6 +192,9 @@ _Gg     = (Fmt.G, Fmt.g)
 _FfEeGg = (Fmt.F, Fmt.f, Fmt.E, Fmt.e) + _Gg  # float formats
 _Fspec_ = NN('[%[<flags>][<width>]', _DOTSTAR_, ']', _BAR_.join(_FfEeGg))  # in testStreprs
 
+del _convergence_, _distant_, _e_, _eps_, _exceeds_, _EQUALSPACED_,\
+    _f_, _F_, _g_, _limit_, _PAREN_g, _RESIDUAL_
+
 
 def anstr(name, OKd=_OKd_, sub=_UNDER_):
     '''Make a valid name of alphanumeric and OKd characters.
@@ -598,9 +602,10 @@ def _xzipairs(names, values, sep=_COMMASPACE_, fmt=NN, pair_fmt=Fmt.COLON):
         raise _ValueError(names=names, values=values, cause=x)
     return (fmt % (t,)) if fmt else t  # enc
 
+
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/trf.py

@@ -1784,7 +1784,7 @@ if __name__ == '__main__':
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/triaxials.py

@@ -7,7 +7,7 @@ I{Charles Karney}'s C++ class U{JacobiConformal<https://GeographicLib.SourceForg
 classGeographicLib_1_1JacobiConformal.html#details>} to pure Python and miscellaneous classes
 L{BetaOmega2Tuple}, L{BetaOmega3Tuple}, L{Jacobi2Tuple} and L{TriaxialError}.
 
-Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2008-2023).  For more information,
+Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2008-2024).  For more information,
 see the U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 
 @see: U{Geodesics on a triaxial ellipsoid<https://WikiPedia.org/wiki/Geodesics_on_an_ellipsoid#
@@ -53,13 +53,13 @@ from pygeodesy.props import Property_RO, property_ROver
 # from pygeodesy.streprs import Fmt  # from .datums
 from pygeodesy.units import Degrees, Float, Height_, Meter, Meter2, Meter3, \
                             Radians, Radius, Scalar_
-from pygeodesy.utily import asin1, atan2d, km2m, m2km, SinCos2, sincos2d_
+from pygeodesy.utily import asin1, atan2, atan2d, km2m, m2km, SinCos2, sincos2d_
 from pygeodesy.vector3d import _otherV3d, Vector3d,  _ALL_LAZY, _MODS
 
-from math import atan2, fabs, sqrt
+from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.triaxials
-__version__ = '24.10.15'
+__version__ = '24.11.24'
 
 _not_ordered_ = _not_('ordered')
 _omega_       = 'omega'
@@ -213,7 +213,7 @@ class Triaxial_(_NamedEnumItem):
                             C{meter}) or an other L{Triaxial} or L{Triaxial_} instance.
            @kwarg b: Middle, C{Y} semi-axis (C{meter}, same units as B{C{a}}), required
                      if C{B{a_triaxial} is scalar}, ignored otherwise.
-           @kwarg c: Small, C{Z} semi-axis (C{meter}, B{C{b}}).
+           @kwarg c: Small, C{Z} semi-axis (C{meter}, like B{C{b}}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TriaxialError: Invalid semi-axis or -axes.
@@ -396,8 +396,10 @@ class Triaxial_(_NamedEnumItem):
            @raise TriaxialError: Non-cartesian B{C{xyz}}, invalid B{C{eps}}, no convergence in
                   root finding or validation failed.
 
-           @see: Methods L{Triaxial.normal3d} and L{Ellipsoid.height4} and I{Eberly}'s U{Distance from a
-                 Point to ...<https://www.GeometricTools.com/Documentation/DistancePointEllipseEllipsoid.pdf>}.
+           @see: Methods L{Triaxial.normal3d} and L{Ellipsoid.height4}, I{Eberly}'s U{Distance from a Point to ...
+                 <https://www.GeometricTools.com/Documentation/DistancePointEllipseEllipsoid.pdf>} and I{Bektas}'
+                 U{Shortest Distance from a Point to Triaxial Ellipsoid<https://www.ResearchGate.net/publication/
+                 272149005_SHORTEST_DISTANCE_FROM_A_POINT_TO_TRIAXIAL_ELLIPSOID>}.
         '''
         v, r = _otherV3d_(x_xyz, y, z), self.isSpherical
 
@@ -420,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)
+        n = _name__(name, name__=self.height4)  # _DUNDER_nameof
         return Vector4Tuple(x, y, z, h, iteration=i, name=n)
 
     @Property_RO
@@ -863,7 +865,8 @@ class Triaxial(Triaxial_):
         return BetaOmega3Tuple(Radians(beta=a), Radians(omega=b), h, **name)
 
     def reverseCartesian(self, x_xyz, y=None, z=None, h=0, normal=True, eps=_EPS2e4, **name):
-        '''"Unproject" a cartesian on to a cartesion I{off} this triaxial's surface.
+        '''Unproject" a cartesian I{on} this triaxial's surface to a cartesion I{off}
+           this triaxial's surface.
 
            @arg x_xyz: X component (C{scalar}) or a cartesian (C{Cartesian},
                        L{Ecef9Tuple}, L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
@@ -871,7 +874,7 @@ class Triaxial(Triaxial_):
                        ignored otherwise.
            @kwarg z: Z component (C{scalar}), like B{C{y}}.
            @arg h: Height above or below this triaxial's surface (C{meter}, same units
-                   as the axes).
+                   as this triaxial's axes).
            @kwarg normal: If C{True}, the height is C{normal} to the surface, otherwise
                           C{radially} to the center of this triaxial (C{bool}).
            @kwarg eps: Tolerance for on-surface test (C{scalar}), see method L{Triaxial.sideOf}.
@@ -941,7 +944,7 @@ class JacobiConformal(Triaxial):
        by C{sqrt(B{a}**2 - B{c}**2) / (2 * B{b})} so that the customary results are
        returned in the case of an ellipsoid of revolution.
 
-       Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2014-2023) and
+       Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2014-2024) and
        licensed under the MIT/X11 License.
 
        @note: This constructor can I{not be used to specify a sphere}, see alternate
@@ -1278,8 +1281,8 @@ def hartzell4(pov, los=False, tri_biax=_WGS84, **name):
         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
-                                          name=_name__(name, name__=hartzell4))
+    n = _name__(name, name__=hartzell4)  # _DUNDER_nameof
+    return Vector4Tuple(v.x, v.y, v.z, h, iteration=i, name=n)
 
 
 def _hypot2_1(x, y, z=0):
@@ -1319,8 +1322,8 @@ def _plumbTo3(px, py, E, eps=EPS):  # in .ellipsoids.Ellipsoid.height4
     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
+        ex = tx**3 * a2
+        ey = ty**3 * b2
 
         qx = px - ex
         qy = py - ey
@@ -1529,13 +1532,17 @@ if __name__ == '__main__':
     from pygeodesy import printf
     from pygeodesy.interns import _COMMA_, _NL_, _NLATvar_
 
+    t = Triaxial_(6378388.0, 6378318.0, 6356911.9461)
+    t = t.height4(3909863.9271, 3909778.123, 3170932.5016)
+    printf('# Bektas: %r', t)
+
     # __doc__ of this file, force all into registery
     t = [NN] + Triaxials.toRepr(all=True, asorted=True).split(_NL_)
     printf(_NLATvar_.join(i.strip(_COMMA_) for i in t))
 
 # **) MIT License
 #
-# Copyright (C) 2022-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2022-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/units.py

@@ -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.10.12'
+__version__ = '24.11.14'
 
 
 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>}.
 
@@ -798,36 +798,36 @@ class Zone(Int):
         return Int_.__new__(cls, arg=arg, name=name, **Error_name_arg)
 
 
-_ScalarU =  Float, Float_, Scalar, Scalar_
-_Degrees = (Azimuth, Bearing, Bearing_, Degrees, Degrees_) + _ScalarU
-_Meters  = (Distance, Distance_, Meter, Meter_) + _ScalarU
-_Radians = (Radians, Radians_) + _ScalarU  # PYCHOK unused
+_Degrees = (Azimuth, Bearing, Bearing_, Degrees, Degrees_)
+_Meters  = (Distance, Distance_, Meter, Meter_)
+_Radians = (Radians, Radians_)  # PYCHOK unused
 _Radii   = _Meters + (Radius, Radius_)
+_ScalarU =  Float, Float_, Scalar, Scalar_
 
 
-def _isDegrees(obj):
+def _isDegrees(obj, iscalar=True):
     # Check for valid degrees types.
-    return isinstance(obj, _Degrees) or _isScalar(obj)
+    return isinstance(obj, _Degrees) or (iscalar and _isScalar(obj))
 
 
-def _isHeight(obj):
+def _isHeight(obj, iscalar=True):
     # Check for valid height types.
-    return isinstance(obj, _Meters) or _isScalar(obj)
+    return isinstance(obj, _Meters) or (iscalar and _isScalar(obj))
 
 
-def _isMeter(obj):
+def _isMeter(obj, iscalar=True):
     # Check for valid meter types.
-    return isinstance(obj, _Meters) or _isScalar(obj)
+    return isinstance(obj, _Meters) or (iscalar and _isScalar(obj))
 
 
-def _isRadius(obj):
+def _isRadius(obj, iscalar=True):
     # Check for valid earth radius types.
-    return isinstance(obj, _Radii) or _isScalar(obj)
+    return isinstance(obj, _Radii) or (iscalar and _isScalar(obj))
 
 
-def _isScalar(obj):
+def _isScalar(obj, iscalar=True):
     # Check for pure scalar types.
-    return isscalar(obj) and not isinstance(obj, _NamedUnit)
+    return isinstance(obj, _ScalarU) or (iscalar and isscalar(obj) and not isinstance(obj, _NamedUnit))
 
 
 def _toUnit(Unit, arg, name=NN, **Error):
@@ -872,7 +872,7 @@ __all__ += _ALL_DOCS(_NamedUnit)
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/unitsBase.py

@@ -349,7 +349,7 @@ __all__ += _ALL_DOCS(_NamedUnit)
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/ups.py

@@ -40,16 +40,16 @@ from pygeodesy.props import deprecated_method, property_doc_, \
                             Property_RO, _update_all
 # from pygeodesy.streprs import Fmt  # from .utmupsBase
 from pygeodesy.units import Float, Float_, Meter, Lat
-from pygeodesy.utily import atan1d, degrees180, sincos2d
+from pygeodesy.utily import atan1d, atan2, degrees180, sincos2d
 from pygeodesy.utmupsBase import Fmt, _LLEB, _hemi, _parseUTMUPS5, _to4lldn, \
                                 _to3zBhp, _to3zll, _UPS_BANDS as _Bands, \
                                 _UPS_LAT_MAX, _UPS_LAT_MIN, _UPS_ZONE, \
                                 _UPS_ZONE_STR, UtmUpsBase
 
-from math import atan2, fabs, radians, tan
+from math import fabs, radians, tan  # as _tan
 
 __all__ = _ALL_LAZY.ups
-__version__ = '24.10.14'
+__version__ = '24.11.26'
 
 _BZ_UPS  = _getPYGEODESY('UPS_POLES', _std_) == _std_
 _Falsing =  Meter(2000e3)  # false easting and northing (C{meter})
@@ -509,7 +509,7 @@ def upsZoneBand5(lat, lon, strict=True, **name):
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),