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

pygeodesy/named.py

@@ -28,16 +28,14 @@ from pygeodesy.interns import MISSING, NN, _AT_, _COLON_, _COLONSPACE_, _COMMA_,
                              _EQUAL_, _exists_, _immutable_, _name_, _NL_, _NN_, \
                              _no_, _other_, _s_, _SPACE_, _std_, _UNDER_, _vs_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-# from pygeodesy.ltp import Ltp, _toLocal, _toLtp  # _MODS
-# from pygeodesy.ltpTuples import Aer, Enu, Ned  # _MODS
 from pygeodesy.props import _allPropertiesOf_n, deprecated_method, _hasProperty, \
                             _update_all, property_doc_, Property_RO, property_RO, \
-                            _update_attrs, property_ROver
+                            _update_attrs
 from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '25.04.14'
+__version__ = '25.04.28'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -915,148 +913,6 @@ class _NamedEnumItem(_NamedBase):
                 raise _AssertionError(t)
 
 
-class _NamedLocal(object):
-    '''(INTERNAL) Base class for C{CartesianBase}, C{Ecef9Tuple} and C{LatLonBase}.
-     '''
-
-    @property_ROver
-    def Ecef(self):
-        '''Get the ECEF I{class} (L{EcefKarney}), I{once}.
-        '''
-        return _MODS.ecef.EcefKarney
-
-    @property_RO
-    def _ecef9(self):
-        '''I{Must be overloaded}.'''
-        notOverloaded(self)
-
-    @Property_RO
-    def _Ltp(self):
-        '''(INTERNAL) Cache this instance' LTP (L{Ltp}).
-        '''
-        return self._ltp.Ltp(self._ecef9, ecef=self.Ecef(self.datum), name=self.name)
-
-    @property_ROver
-    def _ltp(self):
-        '''(INTERNAL) Get module L{pygeodesy.ltp}, I{once}.
-        '''
-        return _MODS.ltp
-
-    def _ltp_toLocal(self, ltp, Xyz_kwds, **Xyz):  # overloaded in C{Ecef9Tuple}
-        '''(INTERNAL) Invoke C{ltp._toLocal}.
-        '''
-        Xyz_ = self._ltp_toLocal2(Xyz_kwds, **Xyz)
-        return self._ltp._toLocal(self, ltp, *Xyz_)  # self._ecef9
-
-    def _ltp_toLocal2(self, Xyz_kwds, _None=None, **Xyz):
-        '''(INTERNAL) Return 2-tuple C{(Xyz_Class, Xyz_kwds)}.
-        '''
-        C, _ = Xyz_ = _xkwds_pop2(Xyz_kwds, **Xyz)
-        if C is not _None:  # validate C
-            n, X = _xkwds_item2(Xyz)
-            if X is not C:
-                _xsubclassof(X, **{n: C})
-        return Xyz_
-
-    @property_ROver
-    def _ltpTuples(self):
-        '''(INTERNAL) Get module L{pygeodesy.ltpTuples}, I{once}.
-        '''
-        return _MODS.ltpTuples
-
-    def toAer(self, ltp=None, **Aer_and_kwds):
-        '''Convert this instance to I{local} I{Azimuth, Elevation, slant Range} (AER) components.
-
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       instance' L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Aer_and_kwds: Optional AER class C{B{Aer}=}L{Aer<pygeodesy.ltpTuples.Aer>}
-                      to use and optionally, additional B{C{Aer}} keyword arguments.
-
-           @return: An B{C{Aer}} instance.
-
-           @raise TypeError: Invalid B{C{ltp}}.
-
-           @see: Method L{toLocal<pygeodesy.named._NamedLocal.toLocal>}.
-        '''
-        return self._ltp_toLocal(ltp, Aer_and_kwds, Aer=self._ltpTuples.Aer)
-
-    def toEnu(self, ltp=None, **Enu_and_kwds):
-        '''Convert this instance to I{local} I{East, North, Up} (ENU) components.
-
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       instance' L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Enu_and_kwds: Optional ENU class C{B{Enu}=}L{Enu<pygeodesy.ltpTuples.Enu>}
-                      to use and optionally, additional B{C{Enu}} keyword arguments.
-
-           @return: An B{C{Enu}} instance.
-
-           @raise TypeError: Invalid B{C{ltp}}.
-
-           @see: Method L{toLocal<pygeodesy.named._NamedLocal.toLocal>}.
-        '''
-        return self._ltp_toLocal(ltp, Enu_and_kwds, Enu=self._ltpTuples.Enu)
-
-    def toLocal(self, Xyz=None, ltp=None, **Xyz_kwds):
-        '''Convert this instance to I{local} components in a I{local tangent plane} (LTP)
-
-           @kwarg Xyz: Optional I{local} components class (L{XyzLocal}, L{Aer},
-                       L{Enu}, L{Ned}) or C{None}.
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       cartesian's L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Xyz_kwds: Optionally, additional B{C{Xyz}} keyword arguments, ignored
-                            if C{B{Xyz} is None}.
-
-           @return: An B{C{Xyz}} instance or a L{Local9Tuple}C{(x, y, z, lat, lon,
-                    height, ltp, ecef, M)} if C{B{Xyz} is None} (with C{M=None}).
-
-           @raise TypeError: Invalid B{C{ltp}}.
-        '''
-        return self._ltp_toLocal(ltp, Xyz_kwds, Xyz=Xyz, _None=Xyz)
-
-    def toLtp(self, Ecef=None, **name):
-        '''Return the I{local tangent plane} (LTP) for this instance.
-
-           @kwarg Ecef: Optional ECEF I{class} (L{EcefKarney}, ... L{EcefYou}), overriding
-                        this instance' L{Ecef<pygeodesy.named._NamedLocal.Ecef>}.
-           @kwarg name: Optional C{B{name}=NN} (C{str}).
-
-           @return: An B{C{Ltp}} instance.
-        '''
-        return self._ltp._toLtp(self, Ecef, self._ecef9, name)  # needs self.Ecef and self._Ltp
-
-    def toNed(self, ltp=None, **Ned_and_kwds):
-        '''Convert this instance to I{local} I{North, East, Down} (NED) components.
-
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       instance' L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Ned_and_kwds: Optional NED class C{B{Ned}=}L{Ned<pygeodesy.ltpTuples.Ned>}
-                      to use and optionally, additional B{C{Ned}} keyword arguments.
-
-           @return: An B{C{Ned}} instance.
-
-           @raise TypeError: Invalid B{C{ltp}}.
-
-           @see: Method L{toLocal<pygeodesy.named._NamedLocal.toLocal>}.
-        '''
-        return self._ltp_toLocal(ltp, Ned_and_kwds, Ned=self._ltpTuples.Ned)
-
-    def toXyz(self, ltp=None, **Xyz_and_kwds):
-        '''Convert this instance to I{local} I{X, Y, Z} (XYZ) components.
-
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       instance' L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Xyz_and_kwds: Optional XYZ class C{B{Xyz}=}L{Xyz<pygeodesy.ltpTuples.XyzLocal>}
-                      to use and optionally, additional B{C{Xyz}} keyword arguments.
-
-           @return: An B{C{Xyz}} instance.
-
-           @raise TypeError: Invalid B{C{ltp}}.
-
-           @see: Method L{toLocal<pygeodesy.named._NamedLocal.toLocal>}.
-        '''
-        return self._ltp_toLocal(ltp, Xyz_and_kwds, Xyz=self._ltpTuples.XyzLocal)
-
-
 # from pygeodesy.props import _NamedProperty
 
 
@@ -1611,7 +1467,6 @@ def _xvalid(name, underOK=False):
 __all__ += _ALL_DOCS(_Named,
                      _NamedBase,  # _NamedDict,
                      _NamedEnum, _NamedEnumItem,
-                     _NamedLocal,
                      _NamedTuple)
 
 # **) MIT License

pygeodesy/resections.py

@@ -18,12 +18,11 @@ from pygeodesy.constants import EPS, EPS0, EPS02, INT0, PI, PI2, PI_2, PI_4, \
                                _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.fmath import favg, Fdot, Fdot_, fidw, _fma, fmean, hypot, hypot2_
 from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1, fsum1f_
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import _a_, _A_, _area_, _b_, _B_, _c_, _C_, _coincident_, \
-                              _colinear_, _d_, _invalid_, _negative_, _not_, \
-                              _rIn_, _SPACE_
+                              _colinear_, _d_, _invalid_, _negative_, _rIn_, _SPACE_
 # from pygeodesy.lazily import _ALL_LAZY  # from .basics
 from pygeodesy.named import _NamedTuple, _Pass,  Fmt
 # from pygeodesy.streprs import Fmt  # from .named
@@ -35,7 +34,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d
 from math import cos, degrees, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.resections
-__version__ = '25.04.14'
+__version__ = '25.05.04'
 
 _concyclic_ = 'concyclic'
 _PA_        = 'PA'
@@ -43,7 +42,6 @@ _PB_        = 'PB'
 _PC_        = 'PC'
 _pointH_    = 'pointH'
 _pointP_    = 'pointP'
-_positive_  = 'positive'
 _radA_      = 'radA'
 _radB_      = 'radB'
 _radC_      = 'radC'
@@ -170,11 +168,9 @@ def cassini(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
 
     A, B, C = _ABC3(useZ, pointA, pointB, pointC)
     try:
-        sa, sb = map1(float, alpha, beta)
-        if min(sa, sb) < 0:
-            raise ValueError(_negative_)
+        sa, sb = _noneg(alpha, beta)
         if fsumf_(_360_0, -sa, -sb) < EPS0:
-            raise ValueError()
+            raise ValueError(_colinear_)
 
         x1, y1 = _H(A, C,  sa)
         x2, y2 = _H(B, C, -sb)
@@ -253,15 +249,15 @@ 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 =  d * s + A.x  # fma(d, s, A.x)
-        y =  d * c + A.y  # fma(d, c, A.y)
+        x = _fma(d, s, A.x)
+        y = _fma(d, c, A.y)
         z = _zidw(x, y, useZ, A, B, C)
         return x, y, z
 
     A, B, C = _ABC3(useZ, pointA, pointB, pointC)
     try:
-        ra, rb = radians(alpha), radians(beta)
-        if min(ra, rb) < 0:
+        ra, rb = t = radians(alpha), radians(beta)
+        if min(t) < 0:
             raise ValueError(_negative_)
 
         sra, srH = sin(ra), sin(ra + rb - PI)  # rH = PI - ((PI - ra) + (PI - rb))
@@ -294,6 +290,15 @@ def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
                              alpha=alpha, beta=beta, cause=x)
 
 
+def _noneg(*xs):
+    '''(INTERNAL) Return non-negative C{float}s.
+    '''
+    xs = tuple(map(float, xs))
+    if min(xs) < 0:
+        raise ValueError(_negative_)
+    return xs
+
+
 def pierlot(point1, point2, point3, alpha12, alpha23, useZ=False, eps=EPS,
                                                     **Clas_and_kwds):
     '''3-Point resection using U{Pierlot<http://www.Telecom.ULg.ac.BE/publi/publications/
@@ -342,7 +347,7 @@ def pierlot(point1, point2, point3, alpha12, alpha23, useZ=False, eps=EPS,
         if eps > 0:
             return c / (min(s, -eps) if s < 0 else max(s, eps))
         t = Fmt.PARENSPACED(eps=eps)
-        raise ValueError(_SPACE_(t, _not_, _positive_))
+        raise ValueError(_SPACE_(t, _invalid_))
 
     B1, B2, B3 = _B3(useZ, point1, point2, point3)
     try:
@@ -400,8 +405,8 @@ def _pierlot3(B1, B2, B3, a12, a23, useZ, _cot):
         #   = (x31 - x23) * (y12 - y23) - (x12 - x23) * (y31 - y23)
         # x = (d * B2.x + K * Y12_23).fover(d)
         # y = (d * B2.y - K * X12_23).fover(d)
-        x, y = _pierlotxy2(B2, -K, Y12_23, X12_23, (X31_23 * Y12_23 -
-                                                    X12_23 * Y31_23))
+        x, y = _pierlotxy2(B2, -K, Y12_23, X12_23, Fdot_(X31_23, Y12_23,
+                                                        -X12_23, Y31_23))
     else:
         x, y, _ = B2.xyz3
     return x, y, _zidw(x, y, useZ, B1, B2, B3)
@@ -492,11 +497,11 @@ def _pierlotx3(a_z_Bs, useZ, _cot, Cs):
     if K:
         cot23 = _cot(*sincos2d(a23))
 
-        # x23 = x2_ + cot23 * y2_
-        # y23 = y2_ - cot23 * x2_
+        # x23 = x2_ + cot23 * y2_  # _fma( cot23, y2_, x2_)
+        # y23 = y2_ - cot23 * x2_  # _fma(-cot23, x2_, y2_)
 
-        # x31 = x1_ + cot23 * y1_
-        # y31 = y1_ - cot23 * x1_
+        # x31 = x1_ + cot23 * y1_  # _fma( cot23, y1_, x1_)
+        # y31 = y1_ - cot23 * x1_  # _fma(-cot23, x1_, y1_)
 
         # x31 - x23 = x1_ + cot23 * y1_ - x2_ - cot23 * y2_
         X31_23 = _Fsumf_(x1_,  cot23 * y1_, -x2_, -cot23 * y2_)
@@ -504,10 +509,10 @@ def _pierlotx3(a_z_Bs, useZ, _cot, Cs):
         Y31_23 = _Fsumf_(y1_, -cot23 * x1_, -y2_,  cot23 * x2_)
 
         # d = (x31 - x23) * (x2_ - x1_) + (y31 - y23) * (y2_ - y1_)
-        # x = (D * B3.x - K * Y31_23).fover(d)
-        # y = (D * B3.y + K * X31_23).fover(d)
-        x, y = _pierlotxy2(B3, K, Y31_23, X31_23, (X31_23 * _Fsumf_(x2_, -x1_) +
-                                                   Y31_23 * _Fsumf_(y2_, -y1_)))
+        # x = (d * B3.x - K * Y31_23).fover(d)
+        # y = (d * B3.y + K * X31_23).fover(d)
+        x, y = _pierlotxy2(B3, K, Y31_23, X31_23, Fdot_(X31_23, _Fsumf_(x2_, -x1_),
+                                                        Y31_23, _Fsumf_(y2_, -y1_)))
     else:
         x, y, _ = B3.xyz3
     return x, y, _zidw(x, y, useZ, B1, B2, B3)
@@ -519,8 +524,8 @@ def _pierlotxy2(B, K, X, Y, D):
     d = float(D)
     if isnear0(d):
         raise ValueError(_or(_coincident_, _colinear_, _concyclic_))
-    x = (D * B.x - K * X).fover(d)
-    y = (D * B.y + K * Y).fover(d)
+    x = Fdot_(D, B.x, -K, X).fover(d)
+    y = Fdot_(D, B.y,  K, Y).fover(d)
     return x, y
 
 
@@ -551,9 +556,7 @@ def snellius3(a, b, degC, alpha, beta):
        @see: Function L{wildberger3}.
     '''
     try:
-        a, b, degC, alpha, beta = t = map1(float, a, b, degC, alpha, beta)
-        if min(t) < 0:
-            raise ValueError(_negative_)
+        a, b, degC, alpha, beta = _noneg(a, b, degC, alpha, beta)
         ra, rb, rC = map1(radians, alpha, beta, degC)
 
         r = fsum1f_(ra, rb, rC) * _0_5
@@ -705,17 +708,15 @@ def triAngle(a, b, c):
 
 def _triAngle(a, b, c):
     # (INTERNAL) To allow callers to embellish errors
-    a, b, c = map1(float, a, b, c)
-    if a < b:
+    a, b, c = _noneg(a, b, c)
+    if b > a:
         a, b = b, a
-    if b < 0 or c < 0:
-        raise ValueError(_negative_)
     if a < EPS0:
         raise ValueError(_coincident_)
     b_a = b / a
     if b_a < EPS0:
         raise ValueError(_coincident_)
-    t = fsumf_(_1_0, b_a**2, -(c / a)**2) / (b_a * _2_0)
+    t = _Fsumf_(_1_0, b_a**2, -(c / a)**2).fover(b_a * _2_0)
     return acos1(t)
 
 
@@ -733,7 +734,7 @@ def triAngle5(a, b, c):
                 C{radA}, C{radB} and C{radC} at triangle corners C{A}, C{B}
                 and C{C}, all in C{radians}, the C{InCircle} radius C{rIn}
                 aka C{inradius}, same units as triangle sides B{C{a}},
-                B{C{b}} and B{C{c}} and the triangle C{area} in those same
+                B{C{b}} and B{C{c}} and the triangle C{area} in the same
                 units I{squared}.
 
        @raise TriangleError: Invalid or negative B{C{a}}, B{C{b}} or B{C{c}}.
@@ -797,15 +798,15 @@ def triArea(a, b, c):
     try:
         r, y, x = sorted(map1(float, a, b, c))
         if r > 0:  # r = min(a, b, c)
-            ab = x - y
-            bc = y - r
-            y += r
-            r = (x + y) * (r - ab) * (r + ab) * (x + bc)
+            z = r
+            d = x - y
+            r = (z + d) * (z - d)
             if r:
-                r = sqrt(r / _16_0)
-        elif r < 0:
+                x += y
+                r *= (x + z) * (x - z)
+        if r < 0:
             raise ValueError(_negative_)
-        return r
+        return sqrt(r / _16_0) if r else _0_0
 
     except (TypeError, ValueError) as x:
         raise TriangleError(a=a, b=b, c=c, cause=x)
@@ -837,11 +838,8 @@ def triSide(a, b, radC):
 
 def _triSide(a, b, radC):
     # (INTERNAL) To allow callers to embellish errors
-    a, b, r = t = map1(float, a, b, radC)
-    if min(t) < 0:
-        raise ValueError(_negative_)
-
-    if a < b:
+    a, b, r = _noneg(a, b, radC)
+    if b < a:
         a, b = b, a
     if a > EPS0:
         ba = b / a
@@ -880,18 +878,21 @@ def triSide2(b, c, radB):
 
 def _triSide2(b, c, radB):
     # (INTERNAL) To allow callers to embellish errors
-    b, c, rB = map1(float, b, c, radB)
-    if min(b, c, rB) < 0:
-        raise ValueError(_negative_)
+    b, c, rB = _noneg(b, c, radB)
     sB, cB = sincos2(rB)
-    if isnear0(sB):
-        if not isnear0(b):
+    if isnear0(b) or isnear0(sB):
+        if isnear0(b) and isnear0(sB):
+            if cB < 0:
+                rA = PI
+                a  = b + c
+            else:
+                rA = _0_0
+                a  = fabs(b - c)
+        else:
             raise ValueError(_invalid_)
-        a, rA = ((b + c), PI) if cB < 0 else (fabs(b - c), _0_0)
-    elif isnear0(b):
-        raise ValueError(_invalid_)
     else:
-        rA = fsumf_(PI, -rB, -asin1(c * sB / b))
+        rC = asin1(c * sB / b)
+        rA = max(fsumf_(PI, -rB, -rC), _0_0)
         a  = sin(rA) * b / sB
     return TriSide2Tuple(a, rA, name=typename(triSide2))
 
@@ -918,9 +919,9 @@ def triSide4(radA, radB, c):
              and functions L{sqrt_a}, L{triSide} and L{triSide2}.
     '''
     try:
-        rA, rB, c = map1(float, radA, radB, c)
+        rA, rB, c = _noneg(radA, radB, c)
         rC = fsumf_(PI, -rA, -rB)
-        if min(rC, rA, rB, c) < 0:
+        if rC < 0:
             raise ValueError(_negative_)
         sa, ca, sb, cb = sincos2_(rA, rB)
         sc = fsum1f_(sa * cb, sb * ca)
@@ -965,18 +966,18 @@ def wildberger3(a, b, c, alpha, beta, R3=min):
         return sin(x)**2
 
     def _vpa(r3, q2, q3, s2, s3):
-        r1 = s2 * q3 / s3
-        r  = r1 * r3 * _4_0
-        n  = (r - _Fsumf_(r1, r3, -q2)**2).fover(s3)
+        r1 =  s2 * q3 / s3
+        r  =  r1 * r3 * _4_0
+        R  = _Fsumf_(r1, r3, -q2)
+        R *=  R  # -(R**2 ...
+        R -=  r  # ... - r) / s3
+        n  = -R.fover(s3)
         if n < 0 or r < EPS0:
             raise ValueError(_coincident_)
         return sqrt((n / r) * q3) if n else _0_0
 
     try:
-        a, b, c, da, db = q = map1(float, a, b, c, alpha, beta)
-        if min(q) < 0:
-            raise ValueError(_negative_)
-
+        a, b, c, da, db = _noneg(a, b, c, alpha, beta)
         q1, q2, q3 = q = a**2, b**2, c**2
         if min(q) < EPS02:
             raise ValueError(_coincident_)
@@ -986,18 +987,19 @@ def wildberger3(a, b, c, alpha, beta, R3=min):
         if min(s) < EPS02:
             raise ValueError(_or(_coincident_, _colinear_))
 
-        q4 =  hypot2_(*q) * _2_0  # a**4 + ...
-        Qs = _Fsumf_(*q)   # == hypot2_(a, b, c)
-        d0 = (Qs**2 - q4).fmul(s1 * s2).fover(s3)
-        if d0 < 0:
-            raise ValueError(_negative_)
+        Q  = _Fsumf_(*q)   # == a**2 + b**2 + ...
         s += _Fsumf_(*s),  # == fsum1(s),
-        C0 =  Fdot(s, q1, q2, q3, -Qs * _0_5)
+        C0 =  Fdot(s, q1, q2, q3, -Q * _0_5)
         r3 =  C0.fover(-s3)  # C0 /= -s3
+        Q *=  Q  # Q**2 - 2 * (a**4 + b**4 ...
+        Q -=  hypot2_(*q) *_2_0  # ... + c**4)
+        d0 =  Q.fmul(s1 * s2).fover(s3)
         if d0 > EPS02:  # > c0
             _xcallable(R3=R3)
             d0 = sqrt(d0)
             r3 = R3(float(C0 + d0), float(C0 - d0))  # XXX min or max
+        elif d0 < (-EPS02):
+            raise ValueError(_negative_)
 
         pa = _vpa(r3, q2, q3, s2, s3)
         pb = _vpa(r3, q1, q3, s1, s3)

pygeodesy/utmupsBase.py

@@ -7,8 +7,8 @@ for modules L{epsg}, L{etm}, L{mgrs}, L{ups} and L{utm}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _isin, isint, isscalar, isstr, neg_, \
-                             _xinstanceof, _xsubclassof
+from pygeodesy.basics import _copysign, _isin, isint, isscalar, isstr, \
+                              neg_, _xinstanceof, _xsubclassof
 from pygeodesy.constants import _float, _0_0, _0_5, _N_90_0, _180_0
 from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.dms import degDMS, parseDMS2
@@ -29,10 +29,10 @@ from pygeodesy.streprs import Fmt, fstr, _fstrENH2, _xzipairs
 from pygeodesy.units import Band, Easting, Lat, Northing, Phi, Scalar, Zone
 from pygeodesy.utily import atan1, _Wrap, wrap360
 
-from math import cos, degrees, fabs, sin, tan
+from math import cos, degrees, fabs, sin, tan  # copysign as _copysign
 
 __all__ = _ALL_LAZY.utmupsBase
-__version__ = '25.04.25'
+__version__ = '25.04.26'
 
 _UPS_BANDS = _A_, _B_, _Y_, _Z_  # UPS polar bands SE, SW, NE, NW
 # _UTM_BANDS = _MODS.utm._Bands
@@ -195,43 +195,65 @@ class UtmUpsBase(_NamedBase):
         self._notOverloaded(self)
 
     def _footpoint(self, y, lat0, makris):
-        '''(INTERNAL) Compute to foot-point latitude in C{radians}.
+        '''(INTERNAL) Return the foot-point latitude in C{radians}.
         '''
+        F = _MODS.fsums.Fsum
+        E = self.datum.ellipsoid
         if y is None:
             _, y = self.eastingnorthing2(falsed=False)
-        S = _MODS.fsums.Fsum
-        E =  self.datum.ellipsoid
-        P =  S(E.Llat(lat0), y)
+        B = F(E.Llat(lat0), y)
         if E.isSpherical:
-            p = P.fover(E.a)
+            r = B.fover(E.a)  # == E.b
+
         elif makris:
-            r = P.fover(E.b)
-            p = fabs(r)
-            if p:
+            b = B.fover(E.b)
+            r = fabs(b)
+            if r:
                 e2 = E.e22  # E.e22abs?
                 e4 = E.e4
 
-                e1  = S(e2 /  4, -11 /  64 * e4, -1).as_iscalar
-                e2  = S(e2 /  8, -13 / 128 * e4)    .as_iscalar
-                e4 *= cos(p)**2 / 8
-
-                s =  sin(p * 2)
-                p = -p
-                U =  S(e1 * p, e2 * s, e4 * p, (5 / 8 * e4) * s**2)
-                p =  atan1(E.a * tan(float(U)) / E.b)
-                if r < 0:  # copysign(p, y)
-                    p = -p
-        else:  # PyGeodetics
+                e1  = F(-1, e2 /  4, -11 /  64 * e4).as_iscalar
+                e2  = F(    e2 /  8, -13 / 128 * e4).as_iscalar
+                e4 *= cos(r)**2 / 8
+
+                s =  sin(r * 2)
+                r = -r
+                U =  F(e1 * r, e2 * s, e4 * r, e4 / 8 * 5 * s**2)
+                r = _copysign(atan1(E.a * tan(float(U)) / E.b), b)
+
+#       elif clins:  # APRIL-ZJU/clins/include/utils/gps_convert_utils.h
+#           n  = E.n
+#           n2 = n**2
+#           n3 = n**3
+#           n4 = n**4
+#           n5 = n**5
+#           A  = F(1, n2 / 4, n4 / 64).fmul((E.a + E.b) / 2)
+#           r  = B.fover(A)
+#           R  = F(r)
+#           if clins:  # FootpointLatitude, GPS-Theory-Practice, 1994
+#               R += F(3 / 2 * n, -27 / 32 * n3,  269 / 512 * n5).fmul(sin(r * 2))
+#               R += F(            21 / 16 * n2,  -55 /  32 * n4).fmul(sin(r * 4))
+#               R += F(           151 / 96 * n3, -417 / 128 * n5).fmul(sin(r * 6))
+#               R +=                            (1097 / 512 * n4)    * sin(r * 8)
+#           else:  # GPS-Theory-Practice, 1992, page 234-235
+#               R += F(-3 / 2 * n, 9 / 16 * n3,  -3 /  32 * n5).fmul(sin(r * 2))
+#               R += F(           15 / 16 * n2, -15 /  32 * n4).fmul(sin(r * 4))
+#               R += F(          -35 / 48 * n3, 105 / 256 * n4).fmul(sin(r * 6))  # n5?
+#           r = float(R)
+
+        else:  # PyGeodetics/src/geodetics/footpoint_latitude.py
             f  = E.f
             f2 = f**2
             f3 = f**3
-            B0 = S(1, -f / 2, f2 / 16, f3 / 32) * E.a
-            r  = P.fover(B0)
-            P  = S(r, S(3 / 4 * f, 3 /  8 * f2, 21 / 256 * f3) * sin(r * 2),
-                      S(          21 / 64 * f2, 21 /  64 * f3) * sin(r * 4),
-                                               151 / 768 * f3  * sin(r * 6))
-            p  = float(P)
-        return p
+            B0 = F(1, -f / 2, f2 / 16, f3 / 32).fmul(E.a)
+            r  = B.fover(B0)
+            R  = F(r)
+            R += F(3 / 4 * f, 3 /  8 * f2, 21 / 256 * f3).fmul(sin(r * 2))
+            R += F(          21 / 64 * f2, 21 /  64 * f3).fmul(sin(r * 4))
+            R +=                         (151 / 768 * f3)    * sin(r * 6)
+            r  = float(R)
+
+        return r
 
     @Property_RO
     def gamma(self):
@@ -251,8 +273,8 @@ class UtmUpsBase(_NamedBase):
     def latFootPoint(self, northing=None, lat0=0, makris=False):
         '''Compute the foot-point latitude in C{degrees}.
 
-           @arg northing: Northing (C{meter}, same units this datum's ellipsoid's axes),
-                          overriding this I{unfalsed} northing.
+           @arg northing: Northing (C{meter}, same units this ellipsoid's axes),
+                          overriding this northing, I{unfalsed}.
            @kwarg lat0: Geodetic latitude of the meridian's origin (C{degrees}).
            @kwarg makris: If C{True}, use C{Makris}' formula, otherwise C{PyGeodetics}'.
 

pygeodesy/vector2d.py

@@ -16,7 +16,7 @@ from pygeodesy.constants import EPS, EPS0, EPS02, EPS4, INF, INT0, \
                                _1_0, _1_0_1T, _N_1_0, _2_0, _N_2_0, _4_0
 from pygeodesy.errors import _and, _AssertionError, IntersectionError, NumPyError, \
                               PointsError, TriangleError, _xError, _xkwds
-from pygeodesy.fmath import fabs, fdot, fdot_, hypot, hypot2_, sqrt
+from pygeodesy.fmath import fabs, fdot, Fdot_, fdot_, hypot, hypot2_, sqrt
 from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1f_
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _a_, _and_, _b_, _c_, _center_, _coincident_, \
@@ -36,7 +36,7 @@ from contextlib import contextmanager
 # from math import fabs, sqrt  # from .fmath
 
 __all__ = _ALL_LAZY.vector2d
-__version__ = '25.04.16'
+__version__ = '25.04.30'
 
 _cA_        = 'cA'
 _cB_        = 'cB'
@@ -755,8 +755,8 @@ def _trilaterate2d2(x1, y1, radius1, x2, y2, radius2, x3, y3, radius3,
         raise IntersectionError(_and(_astr(x1=x1, y1=y1, radius1=r1),
                                      _astr(x2=x2, y2=y2, radius2=r2),
                                      _astr(x3=x3, y3=y3, radius3=r3)), txt=t)
-    t = Vector2Tuple(fdot_(c, e, -b, f) / q,
-                     fdot_(a, f, -c, d) / q, name=typename(trilaterate2d2))
+    t = Vector2Tuple(Fdot_(c, e, -b, f).fover(q),
+                     Fdot_(a, f, -c, d).fover(q), name=typename(trilaterate2d2))
 
     if eps and eps > 0:  # check distances to center vs radius
         for x, y, r in ((x1, y1, r1), (x2, y2, r2), (x3, y3, r3)):