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

pygeodesy/booleans.py

@@ -21,9 +21,9 @@ 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_, _clip_, _clipid_, _COMMASPACE_, \
+from pygeodesy.interns import NN, _BANG_, _clipid_, _COMMASPACE_, \
                              _composite_, _DOT_, _duplicate_, _e_, \
                              _ELLIPSIS_, _few_, _height_, _lat_, _LatLon_, \
                              _lon_, _not_, _points_, _SPACE_, _too_, _X_, \
@@ -43,12 +43,12 @@ from pygeodesy.utily import fabs, _unrollon, _Wrap
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.booleans
-__version__ = '24.09.28'
+__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,16 +316,31 @@ 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)
         return self.__class__(self.y * other, self.x * other)
 
+#   def _edge2(self):
+#       # Return the start and end point of the
+#       # edge containing I{intersection} C{v}.
+#       n = p = self
+#       while p.isintersection:
+#           p = p._prev
+#           if p is self:
+#               break
+#       while n.isintersection:
+#           n = n._next
+#           if n is self:
+#               break
+#       # assert p == self or not p._2Abs(self, n)
+#       return p, n
+
     def _e_x_str(self, t):  # PYCHOK no cover
         if self._label:
             t = NN(self._label, t)
@@ -409,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
@@ -417,21 +432,6 @@ class LatLonFHP(_LatLonBool):
                 n = n._next
         return p._prev, n
 
-#   def _edge2(self):
-#       # Return the start and end point of the
-#       # edge containing I{intersection} C{v}.
-#       n = p = self
-#       while p.isintersection:
-#           p = p._prev
-#           if p is self:
-#               break
-#       while n.isintersection:
-#           n = n._next
-#           if n is self:
-#               break
-#       # assert p == self or not p._2Abs(self, n)
-#       return p, n
-
     def _RPoracle(self, p1, p2, p3):
         # Relative Position oracle
         if p1._linked is self:  # or p1._linked2(self):
@@ -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)
@@ -729,7 +729,7 @@ class _Clip(_Named):
             try:
                 i = cp._clips.index(self)
                 if i != self._id:
-                    kwds[_clip_] = i
+                    kwds.update(clip=i)
             except ValueError:
                 pass
             kwds[_clipid_] = self._id
@@ -1201,7 +1201,7 @@ class _CompositeFHP(_CompositeBase):
     def _clip(self, corners, Union=False, Clas=None,
                            **closed_inull_raiser_eps):
         # Clip this composite with another one, C{corners},
-        # using Foster-Hormann-Popa's algorithm.
+        # using the Foster-Hormann-Popa's algorithm.
         P = self
         Q = self._class(corners, closed_inull_raiser_eps,
                                  eps=P._eps, raiser=False)
@@ -1442,6 +1442,7 @@ class _CompositeGH(_CompositeBase):
                                  raiser=False, xtend=False)
         bt = C._bottom_top_eps2
         lr = C._left_right_eps2
+
         # 1. find intersections
         for s1, s2, Sc in S._edges3(**closed_inull_raiser_xtend_eps):
             if not (_outside(s1.x, s2.x, *lr) or
@@ -1546,45 +1547,45 @@ class _EdgeFHP(object):
             dq  = q2 - q1
             dq2 = dq * dq  # dot product, hypot2
             if dq2 > EPS2:  # like ._clip
-                T,  E  = None, _EdgeFHP  # self.__class__
+                T, _E  = None, _EdgeFHP  # self.__class__
                 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)
                         # distinguish intersection types
-                        T = E.X_INTERSECT if a_0_1 and b_0_1 else (
-                            E.P_INTERSECT if a_0_1 and b_0   else (
-                            E.Q_INTERSECT if a_0   and b_0_1 else (
-                            E.V_INTERSECT if a_0   and b_0   else None)))
+                        T = _E.X_INTERSECT if a_0_1 and b_0_1 else (
+                            _E.P_INTERSECT if a_0_1 and b_0   else (
+                            _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
                     a, a_0, a_0_1, _a_0_1 = _alpha4((d1 * dp) / self._dp2)
                     b, b_0, b_0_1, _b_0_1 = _alpha4((d1 * dq) /     (-dq2))
                     # distinguish overlap type
-                    T = E.X_OVERLAP if  a_0_1 and  b_0_1 else (
-                        E.P_OVERLAP if  a_0_1 and _b_0_1 else (
-                        E.Q_OVERLAP if _a_0_1 and  b_0_1 else (
-                        E.V_OVERLAP if  a_0   and  b_0   else None)))
+                    T = _E.X_OVERLAP if  a_0_1 and  b_0_1 else (
+                        _E.P_OVERLAP if  a_0_1 and _b_0_1 else (
+                        _E.Q_OVERLAP if _a_0_1 and  b_0_1 else (
+                        _E.V_OVERLAP if  a_0   and  b_0   else None)))
 
                 if T:
-                    if T is E.X_INTERSECT:
+                    if T is _E.X_INTERSECT:
                         v = p1 + a * self._dp
                         yield T, (v, p1, p2, a), (v, q1, q2, b)
-                    elif T in E.Vs:
+                    elif T in _E.Vs:
                         yield T, (p1,), (q1,)
                     else:
-                        if T in E.Qs:
+                        if T in _E.Qs:
                             yield T, (p1,), (p1, q1, q2, b)
-                        if T in E.Ps:
+                        if T in _E.Ps:
                             yield T, (q1, p1, p2, a), (q1,)
 
 
@@ -1609,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
@@ -1621,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):
@@ -1649,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
@@ -1693,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)
 
 
@@ -1886,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)
@@ -1898,9 +1899,9 @@ def _alpha4(a):
     # Return 4-tuple (alpha, -EPS < alpha < EPS,
     #                           0 < alpha < 1,
     #                       not 0 < alpha < 1)
-    return (a, False, True,  False) if _0_EPS < a < _EPS_1 else (
-           (a, False, False, True)  if _0_EPS < fabs(a) else
-           (a, True,  False, False))
+    a_EPS = bool(_EPS0 < a < _0EPS)
+    a_0_1 = bool(_0EPS < a < _EPS1)
+    return a, a_EPS, a_0_1, (not a_0_1)
 
 
 def _Cps(Cp, composites_points, where):
@@ -1914,7 +1915,7 @@ def _Cps(Cp, composites_points, where):
 
 
 def _eps0(eps):
-    # Adjust C{eps} or C{None}.
+    # Adjust C{eps} or C{0}.
     return eps if eps and eps > EPS else 0
 
 
@@ -1930,7 +1931,7 @@ def isBoolean(obj):
 
 
 def _left_right_bottom_top_eps2(p1, p2):
-    '''(INTERNAL) Return 2-tuple C{(left, right), (bottom, top)}, oversized.
+    '''(INTERNAL) Return 2-tuple C{((left, right), (bottom, top))}, both oversized.
     '''
     return (_min_max_eps2(p1.x, p2.x),
             _min_max_eps2(p1.y, p2.y))
@@ -1939,18 +1940,23 @@ def _left_right_bottom_top_eps2(p1, p2):
 def _low_high_eps2(lo, hi, eps):
     '''(INTERNAL) Return 2-tuple C{(lo, hi)}, oversized.
     '''
-    lo *= (_1_0 + eps) if lo < 0 else (_1_0 - eps)
-    hi *= (_1_0 - eps) if hi < 0 else (_1_0 + eps)
-    return (lo or -eps), (hi or eps)
+    # assert eps > 0
+    lo -= fabs(eps * lo)
+    hi += fabs(eps * hi)
+    if lo < hi:
+        pass
+    elif lo > hi:
+        lo, hi = hi, lo
+    else:
+        lo -= eps
+        hi += eps
+    return lo, hi
 
 
 def _min_max_eps2(*xs):
     '''(INTERNAL) Return 2-tuple C{(min, max)}, oversized.
     '''
-    lo, hi = min(xs), max(xs)
-    lo *= _1_EPS if lo < 0 else _EPS_1
-    hi *= _EPS_1 if hi < 0 else _1_EPS
-    return (lo or _EPS_0), (hi or _0_EPS)
+    return _low_high_eps2(min(xs), max(xs), EPS)
 
 
 def _other(this, other):
@@ -1963,9 +1969,11 @@ def _other(this, other):
 
 
 def _outside(x1, x2, lo, hi):
-    '''(INTERNAL) Is C{(x1, x2)} outside C{(lo, hi)}?
+    '''(INTERNAL) Are C{x1} and C{x2} outside C{(lo, hi)}?
     '''
-    return max(x1, x2) < lo or min(x1, x2) > hi
+    # assert lo <= hi
+    return (x1 < lo or x2 > hi) if x1 > x2 else \
+           (x2 < lo or x1 > hi)
 
 
 __all__ += _ALL_DOCS(_BooleanBase, _Clip,

pygeodesy/cartesianBase.py

@@ -4,7 +4,7 @@
 u'''(INTERNAL) Private C{CartesianBase} class for elliposiodal, spherical and N-/vectorial
 C{Cartesian}s and public functions L{rtp2xyz}, L{rtp2xyz_}, L{xyz2rtp} and L{xyz2rtp_}.
 
-After I{(C) Chris Veness 2011-2015} published under the same MIT Licence**, see
+After I{(C) Chris Veness 2011-2024} published under the same MIT Licence**, see
 U{https://www.Movable-Type.co.UK/scripts/latlong.html},
 U{https://www.Movable-Type.co.UK/scripts/latlong-vectors.html} and
 U{https://www.Movable-Type.co.UK/scripts/geodesy/docs/latlon-ellipsoidal.js.html}.
@@ -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.08.18'
+__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.09.28'
+__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
@@ -256,7 +256,8 @@ _K0_UTM  = _Float(_K0_UTM = 0.9996)  # PYCHOK in .etm, .ktm, .utm, UTM scale at
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>
 # 1.414213562373095_048_801_688_724_209_698_078_569_671_875_376_948_073_176_679_737_99
 # _1SQRT2= _Float(_1SQRT2 =sqrt(_2_0) + 1)
-_SQRT2_2 = _Float(_SQRT2_2=sqrt(_0_5))  # PYCHOK = 0.707106781186547_6 == sqrt(2) / 2
+# 0.707106781186547_524_400_844_362_104_849_039_284_835_937_688_474_036_588_339_868_99
+_SQRT2_2 = _Float(_SQRT2_2=sqrt(_0_5))  # PYCHOK = 0.707106781186547_5 == sqrt(2) / 2
 
 INF   =  Float(INF =_inf)    # PYCHOK INFinity, see function L{isinf}, L{isfinite}, NOT _Float!
 INT0  =  Int(  INT0= 0)      # PYCHOK unique int(0) instance, see .fsums, useZ=False
@@ -494,20 +495,23 @@ def _umod_PI2(rad):
 
 if __name__ == '__main__':
 
-    from pygeodesy import itemsorted, printf
-
-    t = n = v = []
-    for n, v in itemsorted(locals()):
-        if isinstance(v, (Float, Int, Radius)):
-            printf('%9s: %r', n, v.toRepr(std=False))
-            if v.name != n:
-                raise AssertionError('%r != %r' % (n, v))
-            if v.name is not n:
-                raise AssertionError('%r is not %r' % (n, v))
-            if not n.startswith(_UNDER_):
-                t.append(n)
-    t.append(float_.__name__)
-    printf('__all__ = %r', tuple(t))
+    def _main():
+        from pygeodesy import itemsorted, printf
+
+        t = n = v = []
+        for n, v in itemsorted(locals()):
+            if isinstance(v, (Float, Int, Radius)):
+                printf('%9s: %r', n, v.toRepr(std=False))
+                if v.name != n:
+                    raise AssertionError('%r != %r' % (n, v))
+                if v.name is not n:
+                    raise AssertionError('%r is not %r' % (n, v))
+                if not n.startswith(_UNDER_):
+                    t.append(n)
+        t.append(float_.__name__)
+        printf('__all__ = %r', tuple(t))
+
+    _main()
 
 # **) MIT License
 #

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/datums.py

@@ -8,7 +8,7 @@ Classes L{Datum} and L{Transform} and registries L{Datums} and L{Transforms}, re
 Pure Python implementation of geodesy tools for ellipsoidal earth models, including datums
 and ellipsoid parameters for different geographic coordinate systems and methods for
 converting between them and to cartesian coordinates.  Transcoded from JavaScript originals by
-I{(C) Chris Veness 2005-2016} and published under the same MIT Licence**, see U{latlon-ellipsoidal.js
+I{(C) Chris Veness 2005-2024} and published under the same MIT Licence**, see U{latlon-ellipsoidal.js
 <https://www.Movable-Type.co.UK/scripts/geodesy/docs/latlon-ellipsoidal.js.html>}.
 
 Historical geodetic datums: a latitude/longitude point defines a geographic location on, above
@@ -94,7 +94,7 @@ from pygeodesy.units import _isRadius, Radius_,  radians
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.datums
-__version__ = '24.06.24'
+__version__ = '24.10.12'
 
 _a_ellipsoid_ = _UNDER_(_a_, _ellipsoid_)
 _BD72_        = 'BD72'
@@ -610,7 +610,7 @@ def _mean_radius(radius, *lats):
     return r
 
 
-def _negastr(name):  # in .trf
+def _negastr(name):  # in .trf, test/testTrf
     '''(INTERNAL) Negate a C{Transform/-Xform} name.
     '''
     b, m, p = _BAR_, _MINUS_, _PLUS_

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)