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

pygeodesy/props.py

@@ -13,20 +13,20 @@ choices, see callable L{DeprecationWarnings} below.
 from pygeodesy.basics import isclass as _isclass
 from pygeodesy.errors import _AssertionError, _AttributeError, \
                              _xcallable, _xkwds_get
-# from pygeodesy.internals import _tailof  # from .lazily
+from pygeodesy.internals import _tailof, typename
 from pygeodesy.interns import MISSING, NN, _an_, _COMMASPACE_, \
                              _DEPRECATED_, _DOT_, _EQUALSPACED_, \
                              _immutable_, _invalid_, _module_, \
                              _N_A_, _NL_, _not_, _SPACE_, _UNDER_
 # from pygeodesy.named import callname  # _MODS, avoid circular
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
-                             _FOR_DOCS, _WARNINGS_X_DEV,  _tailof
+                             _FOR_DOCS, _WARNINGS_X_DEV
 # from pygeodesy.streprs import Fmt  # _MODS
 
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '24.11.06'
+__version__ = '25.04.14'
 
 _class_       = 'class'
 _DNL_         = _NL_ * 2  # PYCHOK used!
@@ -45,7 +45,7 @@ def _allPropertiesOf(Clas_or_inst, *Bases, **excls):
         S = Clas_or_inst,  # just this Clas
     else:  # class and super-classes of inst
         try:
-            S = Clas_or_inst.__class__.__mro__[:-1]  # not object
+            S = type(Clas_or_inst).__mro__[:-1]  # not object
         except AttributeError:
             raise
             S = ()  # not an inst
@@ -162,7 +162,7 @@ class _PropertyBase(property):
         _xcallable(getter=method, fget=fget)
 
         self.method = method
-        self.name   = method.__name__
+        self.name   = typename(method)
         d = doc or method.__doc__
         if _FOR_DOCS and d:
             self.__doc__ = d   # PYCHOK no cover
@@ -173,8 +173,8 @@ class _PropertyBase(property):
         '''(INTERNAL) Return an C{AttributeError} instance.
         '''
         if farg:
-            n = _DOT_(self.name, nameter.__name__)
-            n = _SPACE_(n, farg.__name__)
+            n = _DOT_(self.name, typename(nameter))
+            n = _SPACE_(n, typename(farg))
         else:
             n = nameter
         e = _SPACE_(kind, _MODS.named.classname(self))
@@ -349,7 +349,7 @@ class property_RO(_PropertyBase):
             else:
                 d = getattr(inst.__class__, uname, MISSING)
 #               if d is MISSING:  # XXX superfluous
-#                   for c in inst.__class__.__mro__[:-1]:
+#                   for c in type(inst).__mro__[:-1]:
 #                       if uname in c.__dict__:
 #                           d = c.__dict__[uname]
 #                           break
@@ -409,7 +409,7 @@ class property_ROver(_property_RO___):
                 setattr(c, n, v)  # overwrite property_ROver
                 break
         else:
-            n = _DOT_(C.__name__, n)
+            n = _DOT_(typename(C), n)
             raise _AssertionError(_EQUALSPACED_(n, v))
         return v
 
@@ -421,7 +421,7 @@ class _NamedProperty(property):  # in .named
     def name(self):
         '''Get the name of this C{property} (C{str}).
         '''
-        return self.fget.__name__
+        return typename(self.fget)
 
 
 def property_doc_(doc):
@@ -460,16 +460,16 @@ def _deprecated(call, kind, qual_d):
        @see: Brett Slatkin, "Effective Python", 2019 page 105, 2nd
              ed, Addison-Wesley.
     '''
-    doc = _docof(call)
+    doc = _DOCof(call)
 
     @_wraps(call)  # PYCHOK self?
     def _deprecated_call(*args, **kwds):
         if qual_d:  # function
-            q = qual_d
+            q =  qual_d
         elif args:  # method
-            q = _qualified(args[0], call.__name__)
+            q = _qualified(args[0], typename(call))
         else:  # PYCHOK no cover
-            q = call.__name__
+            q =  typename(call)
         _throwarning(kind, q, doc)
         return call(*args, **kwds)
 
@@ -484,8 +484,8 @@ def deprecated_class(cls_or_class):
        @note: NOT a decorator!
     '''
     if _WARNINGS_X_DEV:
-        q = _DOT_(cls_or_class.__module__, cls_or_class.__name__)
-        _throwarning(_class_, q, cls_or_class.__doc__)
+        q = _DOT_(cls_or_class.__module__, typename(cls_or_class))
+        _throwarning(_class_, q, cls_or_class.__doc__)  # _DDOC_
 
 
 def deprecated_function(call):
@@ -496,7 +496,7 @@ def deprecated_function(call):
        @return: The B{C{call}} DEPRECATED.
     '''
     return _deprecated(call, _function_, _DOT_(
-                       call.__module__, call.__name__)) if \
+                       call.__module__, typename(call))) if \
            _WARNINGS_X_DEV else call
 
 
@@ -524,13 +524,13 @@ if _WARNINGS_X_DEV:
         def __init__(self, method):
             '''Decorator for a DEPRECATED C{property} or C{Property} getter.
             '''
-            doc = _docof(method)
+            doc = _DOCof(method)
 
             def _fget(inst):  # PYCHOK no cover
                 '''Get the C{property} or C{Property} value.
                 '''
                 q = _qualified(inst, self.name)
-                _throwarning(property.__name__, q, doc)
+                _throwarning(typename(property), q, doc)
                 return self.method(inst)  # == method
 
             _PropertyBase.__init__(self, method, _fget, None, doc=doc)
@@ -554,7 +554,7 @@ if _WARNINGS_X_DEV:
                     '''Set the C{property} or C{Property} value.
                     '''
                     q = _qualified(inst, self.name)
-                    _throwarning(property.__name__, q, _docof(method))
+                    _throwarning(typename(property), q, _DOCof(method))
                     method(inst, val)
                     # self._update(inst)  # un-cache this item
 
@@ -594,7 +594,7 @@ def deprecated_property_RO(method):
 def _deprecated_RO(method, _RO):
     '''(INTERNAL) Create a DEPRECATED C{property_RO} or C{Property_RO}.
     '''
-    doc = _docof(method)
+    doc = _DOCof(method)
 
     if _WARNINGS_X_DEV:
 
@@ -606,7 +606,7 @@ def _deprecated_RO(method, _RO):
 
             def _fget(self, inst):  # PYCHOK no cover
                 q = _qualified(inst, self.name)
-                _throwarning(_RO.__name__, q, doc)
+                _throwarning(typename(_RO), q, doc)
                 return self.method(inst)
 
         return _Deprecated_RO(method)
@@ -614,7 +614,7 @@ def _deprecated_RO(method, _RO):
         return _RO(method, doc=doc)
 
 
-def _docof(obj):
+def _DOCof(obj):
     '''(INTERNAL) Get uniform DEPRECATED __doc__ string.
     '''
     try:
@@ -629,8 +629,8 @@ def _qualified(inst, name):
     '''(INTERNAL) Fully qualify a name.
     '''
     # _DOT_(inst.classname, name), not _DOT_(inst.named4, name)
-    c =  inst.__class__
-    q = _DOT_(c.__module__, c.__name__, name)
+    t =  type(inst)
+    q = _DOT_(t.__module__, typename(t), name)  # _DMODULE_
     return q
 
 

pygeodesy/resections.py

@@ -12,17 +12,17 @@ L{triAngle}, L{triAngle5}, L{triSide}, L{triSide2} and L{triSide4}.
 # make sure int/int division yields float quotient
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import map1, map2, _zip,  _ALL_LAZY
+from pygeodesy.basics import map1, map2, _zip,  _ALL_LAZY, typename
 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, 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
@@ -34,7 +34,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d
 from math import cos, degrees, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.resections
-__version__ = '24.11.27'
+__version__ = '25.05.04'
 
 _concyclic_ = 'concyclic'
 _PA_        = 'PA'
@@ -42,7 +42,6 @@ _PB_        = 'PB'
 _PC_        = 'PC'
 _pointH_    = 'pointH'
 _pointP_    = 'pointP'
-_positive_  = 'positive'
 _radA_      = 'radA'
 _radB_      = 'radB'
 _radC_      = 'radC'
@@ -169,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)
@@ -204,7 +201,7 @@ 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=which.__name__))
+    return Clas(*args, **_xkwds(kwds, name=typename(which)))
 
 
 def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
@@ -252,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))
@@ -286,13 +283,22 @@ def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_kwds):
         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__)
+        return Collins5Tuple(P, H, a, b, c, name=typename(collins5))
 
     except (TypeError, ValueError) as x:
         raise ResectionError(pointA=pointA, pointB=pointB, pointC=pointC,
                              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/
@@ -341,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:
@@ -399,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)
@@ -491,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_)
@@ -503,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)
@@ -518,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
 
 
@@ -550,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
@@ -576,7 +580,7 @@ def snellius3(a, b, degC, alpha, beta):
 
         pa = _triSide(b, pc, fsumf_(PI, -ra, -pa))
         pb = _triSide(a, pc, fsumf_(PI, -rb, -pb))
-        return Survey3Tuple(pa, pb, pc, name=snellius3.__name__)
+        return Survey3Tuple(pa, pb, pc, name=typename(snellius3))
 
     except (TypeError, ValueError) as x:
         raise TriangleError(a=a, b=b, degC=degC, alpha=alpha, beta=beta, cause=x)
@@ -672,7 +676,7 @@ def tienstra7(pointA, pointB, pointC, alpha, beta=None, gamma=None,
         z = _zidw(x, y, useZ, A, B, C)
 
         P = _Clas(tienstra7, pointA, Clas_and_kwds, x, y, z)
-        return Tienstra7Tuple(P, dA, dB, dC, a, b, c, name=tienstra7.__name__)
+        return Tienstra7Tuple(P, dA, dB, dC, a, b, c, name=typename(tienstra7))
 
     except (TypeError, ValueError) as x:
         raise ResectionError(pointA=pointA, pointB=pointB, pointC=pointC,
@@ -704,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)
 
 
@@ -732,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}}.
@@ -771,7 +773,7 @@ def triAngle5(a, b, c):
             rB, rC = rC, rB
         if ab:
             rA, rB = rB, rA
-        return TriAngle5Tuple(rA, rB, rC, r, s, name=triAngle5.__name__)
+        return TriAngle5Tuple(rA, rB, rC, r, s, name=typename(triAngle5))
 
     except (TypeError, ValueError) as x:
         raise TriangleError(a=a, b=b, c=c, cause=x)
@@ -796,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)
@@ -836,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
@@ -879,20 +878,23 @@ 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=triSide2.__name__)
+    return TriSide2Tuple(a, rA, name=typename(triSide2))
 
 
 def triSide4(radA, radB, c):
@@ -917,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)
@@ -927,7 +929,7 @@ def triSide4(radA, radB, c):
             raise ValueError(_invalid_)
         sc = c / sc
         return TriSide4Tuple((sa * sc), (sb * sc), rC, (sa * sb * sc),
-                             name=triSide4.__name__)
+                             name=typename(triSide4))
 
     except (TypeError, ValueError) as x:
         raise TriangleError(radA=radA, radB=radB, c=c, cause=x)
@@ -964,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_)
@@ -985,24 +987,25 @@ 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)
         pc =  favg(_triSide2(b, pa, ra).a,
                    _triSide2(a, pb, rb).a)
-        return Survey3Tuple(pa, pb, pc, name=wildberger3.__name__)
+        return Survey3Tuple(pa, pb, pc, name=typename(wildberger3))
 
     except (TypeError, ValueError) as x:
         raise TriangleError(a=a, b=b, c=c, alpha=alpha, beta=beta, R3=R3, cause=x)

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__ = '25.01.15'
+__version__ = '25.04.14'
 
 if _unLazy0:  # or _isfrozen
     from pygeodesy.rhumb.aux_ import RhumbAux, RhumbLineAux

pygeodesy/rhumb/aux_.py

@@ -48,7 +48,7 @@ from pygeodesy.rhumb.bases import RhumbBase, RhumbLineBase, \
 from math import ceil as _ceil, fabs, radians
 
 __all__ = _ALL_LAZY.rhumb_aux_
-__version__ = '25.01.15'
+__version__ = '25.04.12'
 
 # DIGITS = (sizeof(real) * 8) bits
 #        = (ctypes.sizeof(ctypes.c_double(1.0)) * 8) bits
@@ -216,11 +216,11 @@ class RhumbLineAux(RhumbLineBase):
            @kwarg lat1: Latitude of the start point (C{degrees90}).
            @kwarg lon1: Longitude of the start point (C{degrees180}).
            @kwarg azi12: Azimuth of this rhumb line (compass C{degrees}).
-           @kwarg caps_name: Optional keyword arguments C{B{name}=NN} and
-                       C{B{caps}=0}, a bit-or'ed combination of L{Caps}
-                       values specifying the required capabilities.  Include
-                       C{Caps.LINE_OFF} if updates to the B{C{rhumb}} should
-                       I{not} be reflected in this rhumb line.
+           @kwarg caps_name: Optional keyword arguments C{B{name}=NN} and C{B{caps}=0},
+                       a bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>} values
+                       specifying the required capabilities.  Include C{Caps.LINE_OFF}
+                       if updates to the B{C{rhumb}} should I{not be reflected} in this
+                       rhumb line.
         '''
         RhumbLineBase.__init__(self, rhumb, lat1, lon1, azi12, **caps_name)
 
@@ -296,7 +296,7 @@ def _RAintegrate(auxD):
 def _RAseries(auxD):
     # Series expansions in n for Fourier coeffients of the integral
     # @see: U{"Series expansions for computing rhumb areas"
-    #       <https:#DOI.org/10.5281/zenodo.7685484>}.
+    #       <https://DOI.org/10.5281/zenodo.7685484>}.
     d  =  n = auxD._n
     i  =  0
     aL =  auxD.ALorder