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

pygeodesy/nvectorBase.py

@@ -11,14 +11,14 @@ and published under the same MIT Licence**, see U{Vector-based geodesy
 '''
 
 # from pygeodesy.basics import map1  # from .namedTuples
-from pygeodesy.constants import EPS, EPS1, EPS_2, R_M, _2_0, _N_2_0
+from pygeodesy.constants import EPS, EPS0, EPS1, EPS_2, R_M, \
+                               _0_0, _1_0, _2_0, _N_2_0
 # from pygeodesy.datums import _spherical_datum  # from .formy
 from pygeodesy.errors import IntersectionError, _ValueError, VectorError, \
                             _xattrs, _xkwds, _xkwds_pop2
-from pygeodesy.fmath import fdot, fidw, hypot_  # PYCHOK fdot shared
+from pygeodesy.fmath import fdot, fidw, hypot  # PYCHOK fdot shared
 from pygeodesy.fsums import Fsum, fsumf_
-from pygeodesy.formy import _isequalTo, n_xyz2latlon, n_xyz2philam, \
-                            _spherical_datum
+from pygeodesy.formy import _isequalTo,  _spherical_datum
 # from pygeodesy.internals import _under  # from .named
 from pygeodesy.interns import NN, _1_, _2_, _3_, _bearing_, _coincident_, \
                              _COMMASPACE_, _distance_, _h_, _insufficient_, \
@@ -26,23 +26,23 @@ from pygeodesy.interns import NN, _1_, _2_, _3_, _bearing_, _coincident_, \
 from pygeodesy.latlonBase import LatLonBase,  _ALL_DOCS, _ALL_LAZY, _MODS
 # from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS  # from .latlonBase
 from pygeodesy.named import _xother3,  _under
-from pygeodesy.namedTuples import Trilaterate5Tuple, Vector3Tuple, \
-                                  Vector4Tuple,  map1
+from pygeodesy.namedTuples import LatLon2Tuple, PhiLam2Tuple, Trilaterate5Tuple, \
+                                  Vector3Tuple, Vector4Tuple,  map1
 from pygeodesy.props import deprecated_method, Property_RO, property_doc_, \
                             property_RO, property_ROnce, _update_all
 from pygeodesy.streprs import Fmt, hstr, unstr
 from pygeodesy.units import Bearing, Height, Radius_, Scalar
-from pygeodesy.utily import sincos2d, _unrollon, _unrollon3
+from pygeodesy.utily import atan2, sincos2d, _unrollon, _unrollon3
 from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 
-from math import fabs, sqrt
+from math import degrees, fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.10.12'
+__version__ = '24.11.24'
 
 
 class NvectorBase(Vector3d):  # XXX kept private
-    '''Base class for ellipsoidal and spherical C{Nvector}s.
+    '''(INTERNAL) Base class for ellipsoidal and spherical C{Nvector}s.
     '''
     _datum = None         # L{Datum}, overriden
     _h     = Height(h=0)  # height (C{meter})
@@ -51,8 +51,8 @@ class NvectorBase(Vector3d):  # XXX kept private
     def __init__(self, x_xyz, y=None, z=None, h=0, datum=None, **ll_name):
         '''New n-vector normal to the earth's surface.
 
-           @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector
-                       (C{Nvector}, L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
+           @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector (C{Nvector},
+                       L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
            @kwarg y: Y component of vector (C{scalar}), required if B{C{x_xyz}} is
                      C{scalar} and same units as B{C{x_xyz}}, ignored otherwise.
            @kwarg z: Z component of vector (C{scalar}), like B{C{y}}.
@@ -159,7 +159,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     def latlon(self):
         '''Get the (geodetic) lat-, longitude in C{degrees} (L{LatLon2Tuple}C{(lat, lon)}).
         '''
-        return n_xyz2latlon(self.x, self.y, self.z, name=self.name)
+        return n_xyz2latlon(self, name=self.name)
 
     @Property_RO
     def latlonheight(self):
@@ -189,7 +189,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     def philam(self):
         '''Get the (geodetic) lat-, longitude in C{radians} (L{PhiLam2Tuple}C{(phi, lam)}).
         '''
-        return n_xyz2philam(self.x, self.y, self.z, name=self.name)
+        return n_xyz2philam(self, name=self.name)
 
     @Property_RO
     def philamheight(self):
@@ -211,89 +211,71 @@ class NvectorBase(Vector3d):  # XXX kept private
 
     @deprecated_method
     def to2ab(self):  # PYCHOK no cover
-        '''DEPRECATED, use property L{philam}.
-
-           @return: A L{PhiLam2Tuple}C{(phi, lam)}.
-        '''
+        '''DEPRECATED, use property L{philam}.'''
         return self.philam
 
     @deprecated_method
     def to3abh(self, height=None):  # PYCHOK no cover
-        '''DEPRECATED, use property L{philamheight} or C{philam.to3Tuple(B{height})}.
-
-           @kwarg height: Optional height, overriding this
-                          n-vector's height (C{meter}).
-
-           @return: A L{PhiLam3Tuple}C{(phi, lam, height)}.
-
-           @raise ValueError: Invalid B{C{height}}.
-        '''
+        '''DEPRECATED, use property L{philamheight} or C{philam.to3Tuple(B{height})}.'''
         return self.philamheight if height in (None, self.h) else \
                self.philam.to3Tuple(height)
 
-    def toCartesian(self, h=None, Cartesian=None, datum=None, **Cartesian_kwds):
+    def toCartesian(self, h=None, Cartesian=None, datum=None, **name_Cartesian_kwds):  # PYCHOK signature
         '''Convert this n-vector to C{Nvector}-based cartesian (ECEF) coordinates.
 
            @kwarg h: Optional height, overriding this n-vector's height (C{meter}).
-           @kwarg Cartesian: Optional class to return the (ECEF) coordinates
-                             (C{Cartesian}).
+           @kwarg Cartesian: Optional class to return the (ECEF) coordinates (C{Cartesian}).
            @kwarg datum: Optional datum (C{Datum}), overriding this datum.
-           @kwarg Cartesian_kwds: Optional, additional B{C{Cartesian}} keyword
-                                  arguments, ignored if C{B{Cartesian} is None}.
+           @kwarg name_Cartesian_kwds: Optional C{B{name}=NN} (C{str}) and optionally, additional
+                       B{C{Cartesian}} keyword arguments, ignored if C{B{Cartesian} is None}.
 
-           @return: The cartesian (ECEF) coordinates (B{C{Cartesian}}) or
-                    if C{B{Cartesian} is None}, an L{Ecef9Tuple}C{(x, y, z,
-                    lat, lon, height, C, M, datum)} with C{C} and C{M} if
-                    available.
+           @return: The (ECEF) coordinates (B{C{Cartesian}}) or if C{B{Cartesian} is None}, an
+                    L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with C{C} and C{M}
+                    if available.
 
-           @raise TypeError: Invalid B{C{Cartesian}} or B{C{Cartesian_kwds}}
-                             argument.
+           @raise TypeError: Invalid B{C{Cartesian}} or B{C{name_Cartesian_kwds}} argument.
 
            @raise ValueError: Invalid B{C{h}}.
         '''
-        D = _spherical_datum(datum or self.datum, name=self.name)
-        E =  D.ellipsoid
-        h =  self.h if h is None else Height(h)
-
-        x, y, z = self.x, self.y, self.z
-        # Kenneth Gade eqn 22
-        n = E.b / hypot_(x * E.a_b, y * E.a_b, z)
-        r = h + n * E.a2_b2
-
-        x *= r
-        y *= r
-        z *= h + n
+        if h is None:
+            h = self.h
+        elif not isinstance(h, Height):
+            h = Height(h=h, Error=VectorError)
+        _, r, v = self._toEcefDrv3(Cartesian, None, datum, h, **name_Cartesian_kwds)
+        if r is None:
+            r = v.toCartesian(Cartesian, **self._name1__(name_Cartesian_kwds))  # h=0
+        return r
 
-        if Cartesian is None:
-            r = self.Ecef(D).reverse(x, y, z, M=True)
+    def _toEcefDrv3(self, CC, LL, datum, h, name=NN, **unused):
+        '''(INTERNAL) Helper for methods C{toCartesian} and C{toLatLon}.
+        '''
+        D = self.datum if datum in (None, self.datum) else \
+           _spherical_datum(datum, name=self.name)
+        if LL is None:
+            v = Vector3d(self, name=name or self.name)  # .toVector3d(norm=False)
+            E = D.ellipsoid
+            r = E.a_b  # Kenneth Gade eqn 22
+            n = v.times_(r, r, _1_0).length
+            n = (E.b / n) if n > EPS0 else _0_0
+            r = E.a2_b2 * n + h  # fma
+            v = v.times_(r, r, n + h)
+            r = self.Ecef(D).reverse(v, M=True) if CC is None else None
         else:
-            kwds = _xkwds(Cartesian_kwds, datum=D)  # h=0
-            r = Cartesian(x, y, z, **kwds)
-        return self._xnamed(r)
+            r = v = None
+        return D, r, v
 
     @deprecated_method
     def to2ll(self):  # PYCHOK no cover
-        '''DEPRECATED, use property L{latlon}.
-
-           @return: A L{LatLon2Tuple}C{(lat, lon)}.
-        '''
+        '''DEPRECATED, use property L{latlon}.'''
         return self.latlon
 
     @deprecated_method
     def to3llh(self, height=None):  # PYCHOK no cover
-        '''DEPRECATED, use property C{latlonheight} or C{latlon.to3Tuple(B{height})}.
-
-           @kwarg height: Optional height, overriding this
-                          n-vector's height (C{meter}).
-
-           @return: A L{LatLon3Tuple}C{(lat, lon, height)}.
-
-           @raise ValueError: Invalid B{C{height}}.
-        '''
+        '''DEPRECATED, use property C{latlonheight} or C{latlon.to3Tuple(B{height})}.'''
         return self.latlonheight if height in (None, self.h) else \
                self.latlon.to3Tuple(height)
 
-    def toLatLon(self, height=None, LatLon=None, datum=None, **LatLon_kwds):
+    def toLatLon(self, height=None, LatLon=None, datum=None, **name_LatLon_kwds):
         '''Convert this n-vector to an C{Nvector}-based geodetic point.
 
            @kwarg height: Optional height, overriding this n-vector's
@@ -301,26 +283,26 @@ class NvectorBase(Vector3d):  # XXX kept private
            @kwarg LatLon: Optional class to return the geodetic point
                           (C{LatLon}) or C{None}.
            @kwarg datum: Optional, spherical datum (C{Datum}).
-           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                               arguments, ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{LatLon}} keyword arguments, ignored if
+                       C{B{LatLon} is None}.
 
            @return: The geodetic point (C{LatLon}) or if C{B{LatLon} is None},
-                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M,
-                    datum)} with C{C} and C{M} if available.
+                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
+                    with C{C} and C{M} if available.
 
-           @raise TypeError: Invalid B{C{LatLon}} or B{C{LatLon_kwds}}
-                             argument.
+           @raise TypeError: Invalid B{C{LatLon}} or B{C{name_LatLon_kwds}} argument.
 
            @raise ValueError: Invalid B{C{height}}.
         '''
-        d = _spherical_datum(datum or self.datum, name=self.name)
-        h =  self.h if height is None else Height(height)
-        # use self.Cartesian(Cartesian=None) for better accuracy of the height
-        # than self.Ecef(d).forward(self.lat, self.lon, height=h, M=True)
-        if LatLon is None:
-            r = self.toCartesian(h=h, Cartesian=None, datum=d)
-        else:
-            kwds = _xkwds(LatLon_kwds, height=h, datum=d)
+        h = self.h if height is None else (
+            height if isinstance(height, Height) else
+            Height(height, Error=VectorError))
+        # use the .toCartesian() logic for better height accuracy instead of
+        # r = self.Ecef(D).forward(self.lat, self.lon, height=h, M=True)
+        D, r, _ = self._toEcefDrv3(None, LatLon, datum, h, **name_LatLon_kwds)
+        if r is None:
+            kwds = _xkwds(name_LatLon_kwds, height=h, datum=D)
             r = LatLon(self.lat, self.lon, **self._name1__(kwds))
         return r
 
@@ -349,7 +331,7 @@ class NvectorBase(Vector3d):  # XXX kept private
            @return: The (normalized) vector (L{Vector3d}).
         '''
         v = Vector3d.unit(self) if norm else self
-        return Vector3d(v.x, v.y, v.z, name=self.name)
+        return Vector3d(v, name=self.name)
 
     @deprecated_method
     def to4xyzh(self, h=None):  # PYCHOK no cover
@@ -373,10 +355,6 @@ class NvectorBase(Vector3d):  # XXX kept private
         return self.xyz.to4Tuple(self.h)
 
 
-NorthPole = NvectorBase(0, 0, +1, name='NorthPole')  # North pole (C{Nvector})
-SouthPole = NvectorBase(0, 0, -1, name='SouthPole')  # South pole (C{Nvector})
-
-
 class _N_vector_(NvectorBase):
     '''(INTERNAL) Minimal, low-overhead C{n-vector}.
     '''
@@ -388,16 +366,19 @@ class _N_vector_(NvectorBase):
             self.name = name
 
 
+NorthPole = _N_vector_(0, 0, +1, name='NorthPole')  # North pole
+SouthPole = _N_vector_(0, 0, -1, name='SouthPole')  # South pole
+
+
 class LatLonNvectorBase(LatLonBase):
-    '''(INTERNAL) Base class for n-vector-based ellipsoidal and
-       spherical C{LatLon} classes.
+    '''(INTERNAL) Base class for n-vector-based ellipsoidal and spherical C{LatLon}s.
     '''
 
     def _update(self, updated, *attrs, **setters):  # PYCHOK _Nv=None
         '''(INTERNAL) Zap cached attributes if updated.
 
-           @see: C{ellipsoidalNvector.LatLon} and C{sphericalNvector.LatLon}
-                 for the special case of B{C{_Nv}}.
+           @see: C{ellipsoidalNvector.LatLon} and C{sphericalNvector.LatLon} for
+                 the special case of B{C{_Nv}}.
         '''
         if updated:
             _Nv, setters = _xkwds_pop2(setters, _Nv=None)
@@ -498,10 +479,10 @@ class LatLonNvectorBase(LatLonBase):
            @raise ValueError: Some B{C{points}} coincide or invalid B{C{distance1}},
                               B{C{distance2}}, B{C{distance3}} or B{C{radius}}.
 
-           @see: U{Trilateration<https://WikiPedia.org/wiki/Trilateration>},
-                 Veness' JavaScript U{Trilateration<https://www.Movable-Type.co.UK/
-                 scripts/latlong-vectors.html>} and method C{LatLon.trilaterate5}
-                 of other, non-C{Nvector LatLon} classes.
+           @see: U{Trilateration<https://WikiPedia.org/wiki/Trilateration>}, I{Veness}'
+                 JavaScript U{Trilateration<https://www.Movable-Type.co.UK/scripts/
+                 latlong-vectors.html>} and method C{LatLon.trilaterate5} of other,
+                 non-C{Nvector LatLon} classes.
         '''
         return _trilaterate(self, distance1, self.others(point2=point2), distance2,
                                              self.others(point3=point3), distance3,
@@ -510,16 +491,13 @@ class LatLonNvectorBase(LatLonBase):
 
     def trilaterate5(self, distance1, point2, distance2, point3, distance3,  # PYCHOK signature
                            area=False, eps=EPS1, radius=R_M, wrap=False):
-        '''B{Not implemented} for C{B{area}=True} and falls back to method
-           C{trilaterate} otherwise.
+        '''B{Not implemented} for C{B{area}=True} and falls back to method C{trilaterate}.
 
-           @return: A L{Trilaterate5Tuple}C{(min, minPoint, max, maxPoint, n)}
-                    with a single trilaterated intersection C{minPoint I{is}
-                    maxPoint}, C{min I{is} max} the nearest intersection
-                    margin and count C{n = 1}.
+           @return: A L{Trilaterate5Tuple}C{(min, minPoint, max, maxPoint, n)} with a
+                    single trilaterated intersection C{minPoint I{is} maxPoint}, C{min
+                    I{is} max} the nearest intersection margin and count C{n = 1}.
 
-           @raise NotImplementedError: Keyword argument C{B{area}=True} not
-                                       (yet) supported.
+           @raise NotImplementedError: Keyword argument C{B{area}=True} not (yet) supported.
 
            @see: Method L{trilaterate} for other and more details.
         '''
@@ -540,6 +518,45 @@ class LatLonNvectorBase(LatLonBase):
         raise IntersectionError(area=area, eps=eps, radius=radius, wrap=wrap, txt=t)
 
 
+def n_xyz2latlon(x_xyz, y=0, z=0, **name):
+    '''Convert C{n-vector} to (geodetic) lat- and longitude in C{degrees}.
+
+       @arg x_xyz: X component (C{scalar}) or (3-D) vector (C{Nvector},
+                   L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
+       @kwarg y: Y component of vector (C{scalar}), required if C{B{x_xyz} is
+                 scalar} and same units as B{C{x_xyz}}, ignored otherwise.
+       @kwarg z: Z component of vector (C{scalar}), like B{C{y}}.
+       @kwarg name: Optional C{B{name}=NN} (C{str}).
+
+       @return: A L{LatLon2Tuple}C{(lat, lon)}.
+
+       @see: Function L{n_xyz2philam}.
+    '''
+    ll = map(degrees, n_xyz2philam(x_xyz, y, z))
+    return LatLon2Tuple(*ll, **name)
+
+
+def n_xyz2philam(x_xyz, y=0, z=0, **name):
+    '''Convert C{n-vector} to (geodetic) lat- and longitude in C{radians}.
+
+       @arg x_xyz: X component (C{scalar}) or (3-D) vector (C{Nvector},
+                   L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
+       @kwarg y: Y component of vector (C{scalar}), required if C{B{x_xyz} is
+                 scalar} and same units as B{C{x_xyz}}, ignored otherwise.
+       @kwarg z: Z component of vector (C{scalar}), like B{C{y}}.
+       @kwarg name: Optional C{B{name}=NN} (C{str}).
+
+       @return: A L{PhiLam2Tuple}C{(phi, lam)}.
+
+       @see: Function L{n_xyz2latlon}.
+    '''
+    try:
+        x, y, z = x_xyz.xyz
+    except AttributeError:
+        x = x_xyz
+    return PhiLam2Tuple(atan2(z, hypot(x, y)), atan2(y, x), **name)
+
+
 def _nsumOf(nvs, h_None, Vector, Vector_kwds):  # .sphericalNvector, .vector3d
     '''(INTERNAL) Separated to allow callers to embellish exceptions.
     '''
@@ -670,7 +687,7 @@ __all__ += _ALL_DOCS(LatLonNvectorBase, NvectorBase, sumOf)  # 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/osgr.py

@@ -53,7 +53,7 @@ from pygeodesy.utily import degrees90, degrees180, sincostan3, truncate
 from math import cos, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.osgr
-__version__ = '24.08.13'
+__version__ = '24.11.06'
 
 _equivalent_ = 'equivalent'
 _OSGR_       = 'OSGR'
@@ -505,20 +505,17 @@ def _ll2LatLon3(ll, LatLon, datum, LatLon_kwds):
 
 
 def parseOSGR(strOSGR, Osgr=Osgr, **name_Osgr_kwds):
-    '''Parse a string representing an OS Grid Reference, consisting
-       of C{"[GD] easting northing"}.
+    '''Parse a string representing an OS Grid Reference, consisting of C{"[GD]
+       easting northing"}.
 
-       Accepts standard OS Grid References like "SU 387 148", with
-       or without whitespace separators, from 2- up to 22-digit
-       references, or all-numeric, comma-separated references in
-       meters, for example "438700,114800".
+       Accepts standard OS Grid References like "SU 387 148", with or without
+       whitespace separators, from 2- up to 22-digit references, or all-numeric,
+       comma-separated references in meters, for example "438700,114800".
 
        @arg strOSGR: An OSGR coordinate (C{str}).
-       @kwarg Osgr: Optional class to return the OSGR coordinate
-                    (L{Osgr}) or C{None}.
-       @kwarg name_Osgr_kwds: Optional C{B{name}=NN} (C{str}) and
-                   optional, additional B{C{Osgr}} keyword arguments,
-                   ignored if C{B{Osgr} is None}.
+       @kwarg Osgr: Optional class to return the OSGR coordinate (L{Osgr}) or C{None}.
+       @kwarg name_Osgr_kwds: Optional C{B{name}=NN} (C{str}) and optionally, additional
+                   B{C{Osgr}} keyword arguments, ignored if C{B{Osgr} is None}.
 
        @return: An (B{C{Osgr}}) instance or if C{B{Osgr} is None}, an
                 L{EasNor2Tuple}C{(easting, northing)}.
@@ -725,7 +722,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/points.py

@@ -1665,7 +1665,7 @@ __all__ += _ALL_DOCS(_Array2LatLon, _Basequence)
 
 # **) 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/props.py

@@ -26,7 +26,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '24.10.19'
+__version__ = '24.11.06'
 
 _class_       = 'class'
 _DNL_         = _NL_ * 2  # PYCHOK used!
@@ -369,7 +369,7 @@ class _property_RO___(_PropertyBase):
         '''
         _PropertyBase.__init__(self, method, self._fget, self._fset_error, doc=doc)
 
-    def _fdel(self, unused):  # PYCHOK no cover
+    def _fdel(self, *unused):  # PYCHOK no cover
         '''Silently ignored, always.
         '''
         pass
@@ -701,7 +701,7 @@ _throwarning        = DeprecationWarnings.throw
 
 # **) 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/resections.py

@@ -15,26 +15,26 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 from pygeodesy.basics import map1, map2, _zip,  _ALL_LAZY
 from pygeodesy.constants import EPS, EPS0, EPS02, INT0, PI, PI2, PI_2, PI_4, \
                                _0_0, _0_5, _1_0, _N_1_0, _2_0, _N_2_0, _4_0, \
-                               _16_0, _180_0, _360_0, _copysign_0_0, isnear0, \
-                               _over, _umod_360
+                               _16_0, _180_0, _360_0, isnear0, _over, _umod_360
 from pygeodesy.errors import _and, _or, TriangleError, _ValueError, _xcallable, \
                              _xkwds, _xkwds_pop2
 from pygeodesy.fmath import favg, Fdot, fidw, fmean, hypot, hypot2_
 from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1, fsum1f_
 from pygeodesy.interns import _a_, _A_, _area_, _b_, _B_, _c_, _C_, _coincident_, \
-                              _colinear_, _d_, _eps_, _invalid_, _negative_, _not_, \
+                              _colinear_, _d_, _invalid_, _negative_, _not_, \
                               _rIn_, _SPACE_
 # from pygeodesy.lazily import _ALL_LAZY  # from .basics
 from pygeodesy.named import _NamedTuple, _Pass,  Fmt
 # from pygeodesy.streprs import Fmt  # from .named
 from pygeodesy.units import Degrees, Distance, Radians
-from pygeodesy.utily import acos1, asin1, sincos2, sincos2_, sincos2d, sincos2d_
+from pygeodesy.utily import acos1, asin1, atan2, sincos2, sincos2_, \
+                            sincos2d, sincos2d_
 from pygeodesy.vector3d import _otherV3d, Vector3d
 
-from math import cos, atan2, degrees, fabs, radians, sin, sqrt
+from math import cos, degrees, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.resections
-__version__ = '24.09.23'
+__version__ = '24.11.27'
 
 _concyclic_ = 'concyclic'
 _PA_        = 'PA'
@@ -200,11 +200,11 @@ def cassini(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
                              alpha=alpha, beta=beta, cause=x)
 
 
-def _Clas(where, point, Clas_and_kwds, *args):
+def _Clas(which, point, Clas_and_kwds, *args):
     '''(INTERNAL) Return a C{B{Clas}=point.classof} survey point.
     '''
     Clas, kwds = _xkwds_pop2(Clas_and_kwds, Clas=point.classof)
-    return Clas(*args, **_xkwds(kwds, name=where.__name__))
+    return Clas(*args, **_xkwds(kwds, name=which.__name__))
 
 
 def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
@@ -252,8 +252,8 @@ def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
 
     def _xyz(d, r, A, B, C, useZ):
         s, c = sincos2(r)
-        x =  A.x + d * s
-        y =  A.y + d * c
+        x =  d * s + A.x  # fma(d, s, A.x)
+        y =  d * c + A.y  # fma(d, c, A.y)
         z = _zidw(x, y, useZ, A, B, C)
         return x, y, z
 
@@ -282,11 +282,10 @@ def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
         d =  b * sin(zb - zh) / sra  # A.minus(P).length
         r =  zh - ra  # zb - PI + (PI - ra - (zb - zh))
         P = _xyz(d, r, A, B, C, useZ)
-        P = _Clas(collins5, pointA, Clas_and_kwds, *P)
 
+        P = _Clas(collins5, pointA, Clas_and_kwds, *P)
         H = _Clas(collins5, pointA, Clas_and_kwds, *H)
         a =  B.minus(C).length
-
         return Collins5Tuple(P, H, a, b, c, name=collins5.__name__)
 
     except (TypeError, ValueError) as x:
@@ -312,7 +311,7 @@ def pierlot(point1, point2, point3, alpha12, alpha23, useZ=False, eps=EPS,
                      B{C{alpha3 - alpha2}}(C{degrees}).
        @kwarg useZ: If C{True}, interpolate the survey point's Z component,
                     otherwise use C{z=INT0} (C{bool}).
-       @kwarg eps: Tolerance for C{cot} (pseudo-)singularities (C{float}).
+       @kwarg eps: Tolerance for C{cot}angent (pseudo-)singularities (C{float}).
        @kwarg Clas_and_kwds: Optional class C{B{Clas}=B{point1}.classof} to
                    return the survey point with optionally other B{C{Clas}}
                    keyword arguments to instantiate the survey point.
@@ -341,7 +340,8 @@ def pierlot(point1, point2, point3, alpha12, alpha23, useZ=False, eps=EPS,
     def _cot(s, c):  # -eps < I{approximate} cotangent < eps
         if eps > 0:
             return c / (min(s, -eps) if s < 0 else max(s, eps))
-        raise ValueError(_SPACE_(_eps_, _not_, _positive_))
+        t = Fmt.PARENSPACED(eps=eps)
+        raise ValueError(_SPACE_(t, _not_, _positive_))
 
     B1, B2, B3 = _B3(useZ, point1, point2, point3)
     try:
@@ -353,7 +353,7 @@ def pierlot(point1, point2, point3, alpha12, alpha23, useZ=False, eps=EPS,
                              alpha12=alpha12, alpha23=alpha23, eps=eps, cause=x)
 
 
-def _pierlot3(B1, B2, B3, a12, a23, useZ, cot):
+def _pierlot3(B1, B2, B3, a12, a23, useZ, _cot):
     '''(INTERNAL) Shared L{pierlot} and L{pierlotx}.
     '''
     x1_, y1_, _ = B1.minus(B2).xyz3
@@ -365,14 +365,14 @@ def _pierlot3(B1, B2, B3, a12, a23, useZ, cot):
     #       = (1 - (c12 * c23) / (s12 * s23)) / (c12 * s23 + s12 * c23) / (s12 * s23)
     #       = (s12 * s23 - c12 * c23) / (c12 * s23 + s12 * c23)
     #       =  c31 / s31
-    cot31 = cot(fsum1f_(c12 * s23,  s12 * c23),  # s31
-                fsum1f_(s12 * s23, -c12 * c23))  # c31
+    cot31 = _cot(fsum1f_(c12 * s23,  s12 * c23),  # s31
+                 fsum1f_(s12 * s23, -c12 * c23))  # c31
 
     K = _Fsumf_(x3_ * x1_,  cot31 * (y3_ * x1_),
                 y3_ * y1_, -cot31 * (x3_ * y1_))
     if K:
-        cot12 = cot(s12, c12)
-        cot23 = cot(s23, c23)
+        cot12 = _cot(s12, c12)
+        cot23 = _cot(s23, c23)
 
         # x12 = x1_ + cot12 * y1_
         # y12 = y1_ - cot12 * x1_
@@ -427,8 +427,8 @@ def pierlotx(point1, point2, point3, alpha1, alpha2, alpha3, useZ=False,
                    return the survey point with optionally other B{C{Clas}}
                    keyword arguments to instantiate the survey point.
 
-       @return: The survey (or robot) point, an instance of B{C{Clas}} or B{C{point1}}'s
-                (sub-)class.
+       @return: The survey (or robot) point, an instance of B{C{Clas}} or
+                B{C{point1}}'s (sub-)class.
 
        @raise ResectionError: Near-coincident, -colinear or -concyclic points or
                               invalid B{C{alpha1}}, B{C{alpha2}} or B{C{alpha3}}.
@@ -450,7 +450,7 @@ def pierlotx(point1, point2, point3, alpha1, alpha2, alpha3, useZ=False,
 
     def _cot(s, c):  # I{exact} cotangent
         try:
-            return (c / s) if c else _copysign_0_0(s)
+            return (c / s)  # if c else _copysign_0_0(s)
         except ZeroDivisionError:
             raise ValueError(_or(_coincident_, _colinear_))
 
@@ -466,7 +466,7 @@ def pierlotx(point1, point2, point3, alpha1, alpha2, alpha3, useZ=False,
                              alpha1=alpha1, alpha2=alpha2, alpha3=alpha3, cause=x)
 
 
-def _pierlotx3(a_z_Bs, useZ, cot, Cs):
+def _pierlotx3(a_z_Bs, useZ, _cot, Cs):
     '''(INTERNAL) Core of L{pierlotx}.
     '''
     (a12, z12, B1), \
@@ -482,14 +482,14 @@ def _pierlotx3(a_z_Bs, useZ, cot, Cs):
         a23,     B2, B3 = a12,     B3, B2
     else:
         Cs(4)
-        return _pierlot3(B1, B2, B3, a12, a23, useZ, cot)
+        return _pierlot3(B1, B2, B3, a12, a23, useZ, _cot)
 
     x1_, y1_, _ = B1.minus(B3).xyz3
     x2_, y2_, _ = B2.minus(B3).xyz3
 
     K = _Fsumf_(y1_ * x2_, -x1_ * y2_)
     if K:
-        cot23 = cot(*sincos2d(a23))
+        cot23 = _cot(*sincos2d(a23))
 
         # x23 = x2_ + cot23 * y2_
         # y23 = y2_ - cot23 * x2_
@@ -1019,7 +1019,7 @@ def _zidw(x, y, useZ, *ABC):
 
 # **) 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/rhumb/__init__.py

@@ -9,7 +9,7 @@ u'''Package of lazily imported C{rhumb} modules L{rhumb.aux_}, L{rhumb.ekx} and
 from pygeodesy.lazily import _ALL_LAZY, _ALL_OTHER, _lazy_import_as, _unLazy0
 
 __all__ = _ALL_LAZY.rhumb
-__version__ = '24.09.02'
+__version__ = '24.11.07'
 
 if _unLazy0:  # or _isfrozen
     from pygeodesy.rhumb.aux_ import RhumbAux, RhumbLineAux
@@ -25,7 +25,7 @@ else:  # lazily import modules and exported attrs
 
 # **) MIT License
 #
-# Copyright (C) 2018-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2018-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"),