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

pygeodesy/booleans.py

@@ -21,7 +21,7 @@ from pygeodesy.basics import isodd, issubclassof, map2, _xscalar
 from pygeodesy.constants import EPS, EPS2, INT0, _0_0, _0_5, _1_0
 from pygeodesy.errors import ClipError, _IsnotError, _TypeError, \
                             _ValueError, _xattr, _xkwds_get, _xkwds_pop2
-from pygeodesy.fmath import favg, hypot, hypot2
+from pygeodesy.fmath import favg, fdot_, hypot, hypot2
 # from pygeodesy.fsums import fsum1  # _MODS
 from pygeodesy.interns import NN, _BANG_, _clipid_, _COMMASPACE_, \
                              _composite_, _DOT_, _duplicate_, _e_, \
@@ -43,12 +43,12 @@ from pygeodesy.utily import fabs, _unrollon, _Wrap
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.booleans
-__version__ = '24.10.22'
+__version__ = '24.11.07'
 
-_0_EPS =  EPS  # near-zero, positive
-_EPS_0 = -EPS  # near-zero, negative
-_1_EPS = _1_0 + EPS   # near-one, over
-_EPS_1 = _1_0 - EPS   # near-one, under
+_0EPS  =  EPS  # near-zero, positive
+_EPS0  = -EPS  # near-zero, negative
+_1EPS  = _1_0 + EPS   # near-one, over
+_EPS1  = _1_0 - EPS   # near-one, under
 _10EPS =  EPS * 10    # see ._2Abs, ._10eps
 
 _alpha_   = 'alpha'
@@ -162,7 +162,7 @@ class _LatLonBool(_Named):
                                       other.x == self.x  and
                                       other.y == self.y)
 
-    def __ne__(self, other):  # required for Python 2
+    def __ne__(self, other):  # required for Python 2  # PYCHOK no cover
         return not self.__eq__(other)
 
     def __repr__(self):
@@ -316,11 +316,11 @@ class LatLonFHP(_LatLonBool):
 
     def __mod__(self, other):  # cross product
         _other(self, other)
-        return self.x * other.y - self.y * other.x
+        return fdot_(self.x, other.y, -self.y, other.x)
 
     def __mul__(self, other):  # dot product
         _other(self, other)
-        return self.x * other.x + self.y * other.y
+        return fdot_(self.x, other.x,  self.y, other.y)
 
     def __rmul__(self, other):  # scalar product
         _xscalar(other=other)
@@ -424,7 +424,7 @@ class LatLonFHP(_LatLonBool):
     def _prev_next2(self):
         # Adjust 2-tuple (._prev, ._next) iff a I{duplicate} intersection
         p, n = self, self._next
-        if self._isduplicate:
+        if self._isduplicate:  # PYCHOK no cover
             p = self._dupof
             while p._isduplicate:
                 p = p._dupof
@@ -580,7 +580,7 @@ class _Clip(_Named):
         '''
         return self._bltr4 > _other(self, other)._bltr4
 
-    def __hash__(self):  # PYCHOK no over
+    def __hash__(self):  # PYCHOK no cover
         return hash(self._bltr4)
 
     def __iter__(self):
@@ -610,7 +610,7 @@ class _Clip(_Named):
         '''
         return self._bltr4 < _other(self, other)._bltr4
 
-    def __ne__(self, other):  # required for Python 2
+    def __ne__(self, other):  # required for Python 2  # PYCHOK no cover
         '''See method C{__eq__}.
         '''
         return not self.__eq__(other)
@@ -1551,10 +1551,10 @@ class _EdgeFHP(object):
                 p1, p2 = self._p1_p2
                 ap1   = p1._2A(q1, q2)
                 ap2_1 = p2._2A(q1, q2) - ap1
-                if fabs(ap2_1) > _0_EPS:  # non-parallel edges
+                if fabs(ap2_1) > _0EPS:  # non-parallel edges
                     aq1   = q1._2A(p1, p2)
                     aq2_1 = q2._2A(p1, p2) - aq1
-                    if fabs(aq2_1) > _0_EPS:
+                    if fabs(aq2_1) > _0EPS:
                         # compute and classify alpha and beta
                         a, a_0, a_0_1, _ = _alpha4(-ap1 / ap2_1)
                         b, b_0, b_0_1, _ = _alpha4(-aq1 / aq2_1)
@@ -1564,7 +1564,7 @@ class _EdgeFHP(object):
                             _E.Q_INTERSECT if a_0   and b_0_1 else (
                             _E.V_INTERSECT if a_0   and b_0   else None)))
 
-                elif fabs(ap1) < _0_EPS:  # parallel or colinear edges
+                elif fabs(ap1) < _0EPS:  # parallel or colinear edges
                     dp = self._dp
                     d1 = q1 - p1
                     # compute and classify alpha and beta
@@ -1610,8 +1610,8 @@ class _EdgeGH(object):
 
     def _alpha2(self, x, y, dx, dy):
         # Return C{(alpha)}, see .points.nearestOn5
-        a = (y * dy + x * dx) / self._hypot2
-        d = (y * dx - x * dy) / self._hypot0
+        a = fdot_(y, dy,  x, dx) / self._hypot2
+        d = fdot_(y, dx, -x, dy) / self._hypot0
         return a, fabs(d)
 
     def _Error(self, n, *args, **kwds):  # PYCHOK no cover
@@ -1622,7 +1622,7 @@ class _EdgeGH(object):
     @Property_RO
     def _hypot0(self):
         _, sx, _, sy = self._x_sx_y_sy
-        return hypot(sx, sy) * _0_EPS
+        return hypot(sx, sy) * _0EPS
 
     @Property_RO
     def _hypot2(self):
@@ -1650,33 +1650,33 @@ class _EdgeGH(object):
             cy = c2.y - c1_y
             d  = cy * sx - cx * sy
 
-            if fabs(d) > _0_EPS:  # non-parallel edges
+            if fabs(d) > _0EPS:  # non-parallel edges
                 dx = x - c1_x
                 dy = y - c1_y
-                ca = (sx * dy - sy * dx) / d
-                if _0_EPS < ca < _EPS_1 or (self._xtend and
-                   _EPS_0 < ca < _1_EPS):
-                    sa = (cx * dy - cy * dx) / d
-                    if _0_EPS < sa < _EPS_1 or (self._xtend and
-                       _EPS_0 < sa < _1_EPS):
+                ca = fdot_(sx, dy, -sy, dx) / d
+                if _0EPS < ca < _EPS1 or (self._xtend and
+                   _EPS0 < ca < _1EPS):
+                    sa = fdot_(cx, dy, -cy, dx) / d
+                    if _0EPS < sa < _EPS1 or (self._xtend and
+                       _EPS0 < sa < _1EPS):
                         yield (y + sa * sy), (x + sa * sx), sa, ca
 
                     # unhandled, "degenerate" cases 1, 2 or 3
-                    elif self._raiser and not (sa < _EPS_0 or sa > _1_EPS):  # PYCHOK no cover
+                    elif self._raiser and not (sa < _EPS0 or sa > _1EPS):  # PYCHOK no cover
                         raise self._Error(1, c1, c2, sa=sa)  # intersection at s1 or s2
 
-                elif self._raiser and not (ca < _EPS_0 or ca > _1_EPS):  # PYCHOK no cover
+                elif self._raiser and not (ca < _EPS0 or ca > _1EPS):  # PYCHOK no cover
                     # intersection at c1 or c2 or at c1 or c2 and s1 or s2
-                    sa = (cx * dy - cy * dx) / d
-                    e = 2 if sa < _EPS_0 or sa > _1_EPS else 3
+                    sa = fdot_(cx, dy, -cy, dx) / d
+                    e  = 2 if sa < _EPS0 or sa > _1EPS else 3
                     raise self._Error(e, c1, c2, ca=ca)
 
             elif parallel and (sx or sy) and (cx or cy):  # PYCHOK no cover
                 # non-null, parallel or colinear edges
                 sa1, d1 = self._alpha2(c1_x - x, c1_y - y, sx, sy)
                 sa2, d2 = self._alpha2(c2.x - x, c2.y - y, sx, sy)
-                if max(d1, d2) < _0_EPS:
-                    if self._xtend and not _outside(sa1, sa2, _EPS_0, _1_EPS):
+                if max(d1, d2) < _0EPS:
+                    if self._xtend and not _outside(sa1, sa2, _EPS0, _1EPS):
                         if sa1 > sa2:  # anti-parallel
                             sa1, sa2 =  sa2,  sa1
                             ca1, ca2 = _1_0, _0_0
@@ -1694,7 +1694,7 @@ class _EdgeGH(object):
                             yield (y + sy), (x + sx), ca2, _alpha1(ca2 - ca)
                         else:  # c2 is between s1 and s2
                             yield (y + sa2 * sy), (x + sa2 * sx), sa2, ca2
-                    elif self._raiser and not _outside(sa1, sa2, _0_0, _1_EPS):
+                    elif self._raiser and not _outside(sa1, sa2, _0_0, _1EPS):
                         raise self._Error(4, c1, c2, d1=d1, d2=d2)
 
 
@@ -1887,9 +1887,9 @@ class BooleanGH(_CompositeGH, _BooleanBase):
         return self._boolean(other, True, False, self.__sub__)
 
 
-def _alpha1(alpha):
+def _alpha1(alpha):  # PYCHOK no cover
     # Return C{alpha} in C{[0..1]} range
-    if _EPS_0 < alpha < _1_EPS:
+    if _EPS0 < alpha < _1EPS:
         return max(_0_0, min(alpha, _1_0))
     t = _not_(Fmt.SQUARE(_ELLIPSIS_(0, 1)))
     raise ClipError(_alpha_, alpha, txt=t)
@@ -1899,8 +1899,8 @@ def _alpha4(a):
     # Return 4-tuple (alpha, -EPS < alpha < EPS,
     #                           0 < alpha < 1,
     #                       not 0 < alpha < 1)
-    a_EPS = bool(_EPS_0 < a < _0_EPS)
-    a_0_1 = bool(_0_EPS < a < _EPS_1)
+    a_EPS = bool(_EPS0 < a < _0EPS)
+    a_0_1 = bool(_0EPS < a < _EPS1)
     return a, a_EPS, a_0_1, (not a_0_1)
 
 

pygeodesy/cartesianBase.py

@@ -43,7 +43,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 # from math import atan2, degrees, fabs, radians, sqrt  # from .fmath, .utily
 
 __all__ = _ALL_LAZY.cartesianBase
-__version__ = '24.10.12'
+__version__ = '24.11.06'
 
 _r_     = 'r'
 _theta_ = 'theta'
@@ -186,7 +186,7 @@ class CartesianBase(Vector3d):
                        or L{Local9Tuple}).
            @kwarg Cartesian: Optional (geocentric) class to return the destination
                              or C{None}.
-           @kwarg name_Cartesian_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+           @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}.
 
@@ -768,7 +768,7 @@ class CartesianBase(Vector3d):
                            (C{Nvector}) or C{None}.
            @kwarg datum: Optional datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2}
                          or L{a_f2Tuple}) overriding this cartesian's datum.
-           @kwarg name_Nvector_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+           @kwarg name_Nvector_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
                        additional B{C{Nvector}} keyword arguments, ignored if
                        C{B{Nvector} is None}.
 
@@ -940,8 +940,8 @@ def rtp2xyz_(r_rtp, theta=0, phi=0, **name_Cartesian_and_kwds):
        @arg theta: Inclination B{C{theta}} (C{radians} with respect to the positive z-axis),
                    required if C{B{r_rtp}} is C{scalar}, ignored otherwise.
        @arg phi: Azimuthal angle B{C{phi}} (C{radians}), like B{C{theta}}.
-       @kwarg name_Cartesian_and_kwds: Optional C{B{name}=NN} (C{str}), a C{B{Cartesian}=None}
-                   class to return the coordinates and optional, additional C{B{Cartesian}}
+       @kwarg name_Cartesian_and_kwds: Optional C{B{name}=NN} (C{str}), C{B{Cartesian}=None}
+                   class to return the coordinates and optionally, additional C{B{Cartesian}}
                    keyword arguments.
 
        @return: A C{B{Cartesian}(x, y, z)} instance or if no C{B{Cartesian}} keyword argument

pygeodesy/constants.py

@@ -10,10 +10,10 @@ L{pygeodesy.isnon0} and L{pygeodesy.remainder}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _copysign, isbool, iscomplex, isint,  _0_0
+from pygeodesy.basics import _copysign, isbool, iscomplex, isint
 from pygeodesy.errors import _xError, _xError2, _xkwds_get1, _xkwds_item2
 # from pygeodesy.fsums import _isFsum_2Tuple  # _MODS
-# from pygeodesy.internals import _0_0  # from .basics
+from pygeodesy.internals import _0_0, _100_0
 from pygeodesy.interns import _INF_, _NAN_, _UNDER_
 from pygeodesy.lazily import _ALL_MODS as _MODS, _ALL_LAZY
 # from pygeodesy.streprs import Fmt  # from .unitsBase
@@ -26,7 +26,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '24.10.15'
+__version__ = '24.11.06'
 
 
 def _copysign_0_0(y):
@@ -185,7 +185,7 @@ _32_0    = _float(  32)       # PYCHOK expected
 _60_0    = _float(  60)       # PYCHOK expected
 _64_0    = _float(  64)       # PYCHOK expected
 _90_0    = _float(  90)       # PYCHOK expected
-_100_0   = _float( 100)       # PYCHOK expected
+_100_0   = _float(_100_0)     # PYCHOK expected
 _180_0   = _float( 180)       # PYCHOK expected
 _270_0   = _float( 270)       # PYCHOK expected
 _360_0   = _float( 360)       # PYCHOK expected

pygeodesy/css.py

@@ -33,7 +33,7 @@ from pygeodesy.units import Azimuth, Degrees, Easting, Height, _heigHt, \
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.css
-__version__ = '24.07.25'
+__version__ = '24.11.06'
 
 
 def _CS0(cs0):
@@ -313,16 +313,15 @@ class CassiniSoldner(_NamedBase):
         self._sb0, self._cb0 = _norm2(s * g.f1, c)
 
     def reverse(self, easting, northing, LatLon=None, **name_LatLon_kwds):
-        '''Convert a Cassini-Soldner location to (ellipsoidal) geodetic
-           lat- and longitude.
+        '''Convert a Cassini-Soldner location to (ellipsoidal) geodetic lat- and longitude.
 
            @arg easting: Easting of the location (C{meter}).
            @arg northing: Northing of the location (C{meter}).
-           @kwarg LatLon: Optional, ellipsoidal class to return the geodetic
-                          location as (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional name C{B{name}=NN} (C{str}) and
-                       optional, additional B{C{LatLon}} keyword arguments,
-                       ignored if C{B{LatLon} is None}.
+           @kwarg LatLon: Optional, ellipsoidal class to return the geodetic location as
+                          (C{LatLon}) or C{None}.
+           @kwarg name_LatLon_kwds: Optional name C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{LatLon}} keyword arguments, ignored if C{B{LatLon}
+                       is None}.
 
            @return: Geodetic location B{C{LatLon}} or if C{B{LatLon} is None},
                     a L{LatLon2Tuple}C{(lat, lon)}.

pygeodesy/deprecated/__init__.py

@@ -27,7 +27,7 @@ __all__ = (_ALL_DEPRECATED.deprecated_bases +
            _ALL_DEPRECATED.deprecated_classes +
            _ALL_DEPRECATED.deprecated_consterns +
            _ALL_DEPRECATED.deprecated_functions)
-__version__ = '24.09.19'
+__version__ = '24.11.07'
 
 if _unLazy0:
     from pygeodesy.deprecated import bases, datum, nvector, rhumbBase, \

pygeodesy/deprecated/classes.py

@@ -22,7 +22,7 @@ from pygeodesy.trf import TRFXform7Tuple as _TRFXform7Tuple
 from pygeodesy.units import Bearing, Int, Lamd, Lat, Lon, Meter, Phid
 
 __all__ = _ALL_DEPRECATED.deprecated_classes
-__version__ = '24.07.02'
+__version__ = '24.11.07'
 
 
 class _Deprecated_NamedTuple(_NamedTuple):
@@ -153,7 +153,7 @@ def HeightIDW3(knots, **kwds):  # PYCHOK no cover
 
 class Lam_(Lamd):
     '''DEPRECATED on 2024.06.15, use class L{Lamd}.'''
-    def __init__(self, *args, **kwds):  # PYCHOK signature
+    def __init__(self, *args, **kwds):  # PYCHOK no cover
         deprecated_class(self.__class__)
         Lamd.__init__(self, *args, **kwds)
 
@@ -172,7 +172,7 @@ class NearestOn4Tuple(_Deprecated_NamedTuple):  # PYCHOK no cover
 
 class Phi_(Phid):
     '''DEPRECATED on 2024.06.15, use class L{Phid}.'''
-    def __init__(self, *args, **kwds):  # PYCHOK signature
+    def __init__(self, *args, **kwds):  # PYCHOK no cover
         deprecated_class(self.__class__)
         Phid.__init__(self, *args, **kwds)
 
@@ -205,22 +205,22 @@ class Rhumb7Tuple(_Deprecated_NamedTuple):
     _Units_ = _Rhumb8Tuple._Units_[:7]
 
     @deprecated_method
-    def toDirect9Tuple(self, **kwds):
+    def toDirect9Tuple(self, **kwds):  # PYCHOK no cover
         return self.toRhumb8Tuple().toDirect9Tuple(self, **kwds)
 
     @deprecated_method
-    def toGDict(self, **kwds):
+    def toGDict(self, **kwds):  # PYCHOK no cover
         return self.toRhumb8Tuple().toGDict(**kwds)
 
     @deprecated_method
-    def toInverse10Tuple(self, **kwds):
+    def toInverse10Tuple(self, **kwds):  # PYCHOK no cover
         return self.toRhumb8Tuple().toInverse10Tuple(self, **kwds)
 
     @deprecated_method
-    def toRhumb8Tuple(self, dflt=NAN):
+    def toRhumb8Tuple(self, dflt=NAN):  # PYCHOK no cover
         return _Rhumb8Tuple(self + (dflt,), name=self.name)
 
-    def _to7Tuple(self):
+    def _to7Tuple(self):  # PYCHOK no cover
         '''(INTERNAL) see L{Rhumb8Tuple._to7Tuple}.
         '''
         return self
@@ -266,7 +266,7 @@ class UtmUps4Tuple(_Deprecated_NamedTuple):  # PYCHOK no cover
 
 class XDist(ADict):
     '''DEPRECATED on 2024.07.02, use class L{XDict}.'''
-    def __init__(self, *args, **kwds):  # PYCHOK signature
+    def __init__(self, *args, **kwds):  # PYCHOK no cover
         deprecated_class(self.__class__)
         ADict.__init__(self, *args, **kwds)
 

pygeodesy/deprecated/functions.py

@@ -14,7 +14,7 @@ from pygeodesy.props import deprecated_function
 from pygeodesy.units import Number_, Scalar_
 
 __all__ = _ALL_DEPRECATED.deprecated_functions
-__version__ = '24.09.19'
+__version__ = '24.11.07'
 
 _WGS84 = _UTM = object()
 
@@ -32,7 +32,7 @@ def areaof(points, adjust=True, radius=R_M, wrap=True):  # PYCHOK no cover
 
 
 @deprecated_function
-def atand(x):
+def atand(x):  # PYCHOK no cover
     '''DEPRECATED on 2023.09.28, use function L{pygeodesy.atan1d}.'''
     return _MODS.utily.atan1d(x)
 
@@ -124,19 +124,19 @@ def equirectangular3(lat1, lon1, lat2, lon2, **options):  # PYCHOK no cover
 
 
 @deprecated_function
-def excessAbc(A, b, c):
+def excessAbc(A, b, c):  # PYCHOK no cover
     '''DEPRECATED on 2023.04.04, use function L{pygeodesy.excessAbc_}.'''
     return _MODS.formy.excessAbc_(A, b, c)
 
 
 @deprecated_function
-def excessGirard(A, B, C):
+def excessGirard(A, B, C):  # PYCHOK no cover
     '''DEPRECATED on 2023.04.04, use function L{pygeodesy.excessGirard_}.'''
     return _MODS.formy.excessGirard_(A, B, C)
 
 
 @deprecated_function
-def excessLHuilier(a, b, c):
+def excessLHuilier(a, b, c):  # PYCHOK no cover
     '''DEPRECATED on 2023.04.04, use function L{pygeodesy.excessLHuilier_}.'''
     return _MODS.formy.excessLHuilier_(a, b, c)
 
@@ -176,7 +176,7 @@ def falsed2f(falsed=True, Error=ValueError, **name_value):  # PYCHOK no cover
 
 
 @deprecated_function
-def float0(*xs):
+def float0(*xs):  # PYCHOK no cover
     '''DEPRECATED on 2023.04.21, use function L{pygeodesy.float0_}.'''
     return float0_(*xs)
 

pygeodesy/ecef.py

@@ -86,7 +86,7 @@ from pygeodesy.utily import atan1, atan1d, atan2d, degrees90, degrees180, \
 from math import atan2, cos, degrees, fabs, radians, sqrt
 
 __all__ = _ALL_LAZY.ecef
-__version__ = '24.06.12'
+__version__ = '24.10.28'
 
 _Ecef_    = 'Ecef'
 _prolate_ = 'prolate'
@@ -383,8 +383,8 @@ class EcefFarrell21(_EcefBase):
             lon = self._polon(y, x, p, **lon00_name)
             # note, phi and lam are swapped on page 29
 
-        except (ValueError, ZeroDivisionError) as e:
-            raise EcefError(x=x, y=y, z=z, cause=e)
+        except (ValueError, ZeroDivisionError) as X:
+            raise EcefError(x=x, y=y, z=z, cause=X)
 
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    1, None, self.datum,
@@ -638,9 +638,8 @@ class EcefSudano(_EcefBase):
         R = hypot(x, y)  # Rh
         d = e - R
 
-        _a  = fabs
         lat = atan1d(z, R * E.e21)
-        sa, ca = sincos2d(_a(lat))
+        sa, ca = sincos2d(fabs(lat))
         # Sudano's Eq (A-6) and (A-7) refactored/reduced,
         # replacing Rn from Eq (A-4) with n = E.a / ca:
         # N = ca**2 * ((z + E.e2 * n * sa) * ca - R * sa)
@@ -650,32 +649,30 @@ class EcefSudano(_EcefBase):
         #   = ca**2 * (E.e2 * E.a / E.e2s2(sa) - R / ca**2)
         # N / D = (z * ca + (E.e2 * E.a - R) * sa) /
         #         (E.e2 * E.a / E.e2s2(sa) - R / ca**2)
-        _E  = EPS_2
         tol = self.tolerance
         _S2 = Fsum(sa).fsum2f_
-        _rt = sqrt
         for i in range(1, _TRIPS):
             ca2 = _1_0 - sa**2
-            if ca2 < _E:  # PYCHOK no cover
+            if ca2 < EPS_2:  # PYCHOK no cover
                 ca = _0_0
                 break
-            ca = _rt(ca2)
+            ca = sqrt(ca2)
             r = e / E.e2s2(sa) - R / ca2
-            if _a(r) < _E:
+            if fabs(r) < EPS_2:
                 break
             lat = None
-            sa, r = _S2(-z * ca / r, -d * sa / r)
-            if _a(r) < tol:
+            sa, t = _S2(-z * ca / r, -d * sa / r)
+            if fabs(t) < tol:
                 break
         else:
             t = unstr(self.reverse, x=x, y=y, z=z)
             raise EcefError(t, txt=Fmt.no_convergence(r, tol))
 
         if lat is None:
-            lat = copysign0(atan1d(_a(sa), ca), z)
+            lat = copysign0(atan1d(fabs(sa), ca), z)
         lon = self._polon(y, x, R, **lon00_name)
 
-        h = fsumf_(R * ca, _a(z * sa), -E.a * E.e2s(sa))  # use Veness'
+        h = fsumf_(R * ca, fabs(z * sa), -E.a * E.e2s(sa))  # use Veness'
         # because Sudano's Eq (7) doesn't produce the correct height
         # h = (fabs(z) + R - E.a * cos(a + E.e21) * sa / ca) / (ca + sa)
         return Ecef9Tuple(x, y, z, lat, lon, h,