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

pygeodesy/azimuthal.py

@@ -49,7 +49,7 @@ from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB, \
                               _xinstanceof
 from pygeodesy.datums import _spherical_datum, _WGS84
 from pygeodesy.errors import _ValueError, _xdatum, _xkwds
-from pygeodesy.fmath import euclid, hypot as _hypot,  Fsum
+from pygeodesy.fmath import euclid, fdot_, hypot as _hypot,  Fsum
 # from pygeodesy.fsums import Fsum  # from .fmath
 # from pygeodesy.formy import antipode  # _MODS
 from pygeodesy.interns import _azimuth_, _datum_, _lat_, _lon_, _scale_, \
@@ -64,13 +64,13 @@ from pygeodesy.props import deprecated_Property_RO, Property_RO, \
 from pygeodesy.streprs import Fmt, _fstrLL0, unstr
 from pygeodesy.units import Azimuth, Easting, Lat_, Lon_, Northing, \
                             Scalar, Scalar_
-from pygeodesy.utily import asin1, atan1, atan2b, atan2d, sincos2, \
-                            sincos2d, sincos2d_
+from pygeodesy.utily import asin1, atan1, atan2, atan2b, atan2d, \
+                            sincos2, sincos2d, sincos2d_
 
-from math import acos, atan2, degrees, fabs, sin, sqrt
+from math import acos, degrees, fabs, sin, sqrt
 
 __all__ = _ALL_LAZY.azimuthal
-__version__ = '24.07.25'
+__version__ = '24.11.24'
 
 _EPS_K         = _EPStol * _0_1  # Karney's eps_ or _EPSmin * _0_1?
 _over_horizon_ = 'over horizon'
@@ -154,10 +154,10 @@ class _AzimuthalBase(_NamedBase):
         s0, c0 = self._sc0
 
         cb  *= ca
-        k, t = _k_t_2(s0 * sa + c0 * cb)
+        k, t = _k_t_2(fdot_(s0, sa, c0, cb))
         if t:
             r = k * self.radius
-            y = r * (c0 * sa - s0 * cb)
+            y = r * fdot_(c0, sa, -s0, cb)
             e, n, z, _ = _enzh4(r * sb * ca, y, None)
         else:  # 0 or 180
             e = n = z = _0_0
@@ -233,11 +233,11 @@ class _AzimuthalBase(_NamedBase):
                                      Lon_(lon0=lon0, Error=AzimuthalError))
         self._sc0     = sincos2d(self.lat0)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):  # PYCHOK no cover
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''I{Must be overloaded}.'''
-        self._notOverloaded(x, y, LatLon=LatLon, **name_LatLon_kwds)
+        self._notOverloaded(x, y, **name_LatLon_and_kwds)  # PYCHOK no cover
 
-    def _reverse(self, x, y, _c, lea, LatLon, **name_LatLon_kwds):
+    def _reverse(self, x, y, _c, lea, LatLon=None, **name_LatLon_kwds):
         '''(INTERNAL) Azimuthal (spherical) reverse C{x, y} to C{lat, lon}.
         '''
         e, n, z, r = _enzh4(x, y)
@@ -379,15 +379,14 @@ class Equidistant(_AzimuthalBase):
 
         return self._forward(lat, lon, name, _k_t)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal equidistant location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} forthe location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       to use and optionally, additional B{C{LatLon}} keyword arguments,
+                       ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
@@ -401,7 +400,7 @@ class Equidistant(_AzimuthalBase):
         def _c(c):
             return c if c > EPS else None
 
-        return self._reverse(x, y, _c, False, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, False, **name_LatLon_and_kwds)
 
 
 def equidistant(lat0, lon0, datum=_WGS84, exact=False, geodsolve=False, **name):
@@ -505,9 +504,8 @@ class _EquidistantBase(_AzimuthalGeodesic):
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
            @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} and optionally, additional
+                       B{C{LatLon}} keyword arguments, ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
@@ -670,15 +668,14 @@ class Gnomonic(_AzimuthalBase):
 
         return self._forward(lat, lon, name, _k_t)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal equidistant location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       for the location and optionally, additional B{C{LatLon}} keyword
+                       arguments, ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
@@ -692,7 +689,7 @@ class Gnomonic(_AzimuthalBase):
         def _c(c):
             return atan1(c) if c > EPS else None
 
-        return self._reverse(x, y, _c, False, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, False, **name_LatLon_and_kwds)
 
 
 def gnomonic(lat0, lon0, datum=_WGS84, exact=False, geodsolve=False, **name):
@@ -787,20 +784,18 @@ class _GnomonicBase(_AzimuthalGeodesic):
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
            @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and optionally,
+                       additional B{C{LatLon}} keyword arguments, ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
 
            @raise AzimuthalError: No convergence.
 
-           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon}
-                  in the range C{[-180..180] degrees}.  The C{azimuth} is clockwise
-                  from true North.  The scale is C{1 / reciprocal**2} in C{radial}
-                  direction and C{1 / reciprocal} in the direction perpendicular
-                  to this.
+           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon} in the range
+                  C{[-180..180] degrees}.  The C{azimuth} is clockwise from true North.  The
+                  scale is C{1 / reciprocal**2} in C{radial} direction and C{1 / reciprocal}
+                  in the direction perpendicular to this.
         '''
         e, n, z, q = _enzh4(x, y)
 
@@ -974,30 +969,28 @@ class LambertEqualArea(_AzimuthalBase):
 
         return self._forward(lat, lon, name, _k_t)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal Lambert-equal-area location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location
-                              and optional, additional B{C{LatLon}} keyword
-                              arguments, ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       to use and optionally, additional B{C{LatLon}} keyword arguments,
+                       ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
 
-           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon}
-                  in the range C{[-180..180] degrees}.  The C{scale} of the
-                  projection is C{1} in I{radial} direction, C{azimuth} clockwise
-                  from true North and is C{1 / reciprocal} in the direction
-                  perpendicular to this.
+           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon} in the
+                  range C{[-180..180] degrees}.  The C{scale} of the projection is C{1}
+                  in I{radial} direction, C{azimuth} clockwise from true North and is C{1
+                  / reciprocal} in the direction perpendicular to this.
         '''
         def _c(c):
             c *= _0_5
             return (asin1(c) * _2_0) if c > EPS else None
 
-        return self._reverse(x, y, _c, True, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, True, **name_LatLon_and_kwds)
 
 
 class Orthographic(_AzimuthalBase):
@@ -1028,29 +1021,27 @@ class Orthographic(_AzimuthalBase):
 
         return self._forward(lat, lon, name, _k_t)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal orthographic location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       to use and optionally, additional B{C{LatLon}} keyword arguments,
+                       ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
 
-           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon}
-                  in the range C{[-180..180] degrees}.  The C{scale} of the
-                  projection is C{1} in I{radial} direction, C{azimuth} clockwise
-                  from true North and is C{1 / reciprocal} in the direction
-                  perpendicular to this.
+           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon} in the
+                  range C{[-180..180] degrees}.  The C{scale} of the projection is C{1}
+                  in I{radial} direction, C{azimuth} clockwise from true North and is C{1
+                  / reciprocal} in the direction perpendicular to this.
         '''
         def _c(c):
             return asin1(c) if c > EPS else None
 
-        return self._reverse(x, y, _c, False, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, False, **name_LatLon_and_kwds)
 
 
 class Stereographic(_AzimuthalBase):
@@ -1101,35 +1092,34 @@ class Stereographic(_AzimuthalBase):
         self._k0  = Scalar_(factor, name=n, low=EPS, high=2)  # XXX high=1, 2, other?
         self._k02 = self._k0 * _2_0
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal stereographic location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       to use and optionally, additional B{C{LatLon}} keyword arguments,
+                       ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
 
            @note: The C{lat} will be in range C{[-90..90] degrees}, C{lon} in range
-                  C{[-180..180] degrees} and C{azimuth} clockwise from true North.
-                  The C{scale} of the projection is C{1} in I{radial} direction and
-                  is C{1 / reciprocal} in the direction perpendicular to this.
+                  C{[-180..180] degrees} and C{azimuth} clockwise from true North.  The
+                  C{scale} of the projection is C{1} in I{radial} direction and is C{1
+                  / reciprocal} in the direction perpendicular to this.
         '''
         def _c(c):
             return (atan2(c, self._k02) * _2_0) if c > EPS else None
 
-        return self._reverse(x, y, _c, False, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, False, **name_LatLon_and_kwds)
 
 
 __all__ += _ALL_DOCS(_AzimuthalBase, _AzimuthalGeodesic, _EquidistantBase, _GnomonicBase)
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/basics.py

@@ -37,7 +37,7 @@ from math import copysign as _copysign
 # import inspect as _inspect  # _MODS
 
 __all__ = _ALL_LAZY.basics
-__version__ = '24.10.14'
+__version__ = '24.11.02'
 
 _below_           = 'below'
 _list_tuple_types = (list, tuple)
@@ -111,29 +111,29 @@ except NameError:  # Python 3+
         return ub
 
 
-def _args_kwds_count2(func, exelf=True):
-    '''(INTERNAL) Get a C{func}'s args and kwds count as 2-tuple
-       C{(nargs, nkwds)}, including arg C{self} for methods.
-
-       @kwarg exelf: If C{True}, exclude C{self} in the C{args}
-                     of a method (C{bool}).
-    '''
-    i = _MODS.inspect
-    try:  # PYCHOK no cover
-        a = k = 0
-        for _, p in i.signature(func).parameters.items():
-            if p.kind is p.POSITIONAL_OR_KEYWORD:
-                if p.default is p.empty:
-                    a += 1
-                else:
-                    k += 1
-    except AttributeError:  # Python 2-
-        s = i.getargspec(func)
-        k = len(s.defaults or ())
-        a = len(s.args) - k
-    if exelf and a > 0 and i.ismethod(func):
-        a -= 1
-    return a, k
+# def _args_kwds_count2(func, exelf=True):  # in .formy
+#     '''(INTERNAL) Get a C{func}'s args and kwds count as 2-tuple
+#        C{(nargs, nkwds)}, including arg C{self} for methods.
+#
+#        @kwarg exelf: If C{True}, exclude C{self} in the C{args}
+#                      of a method (C{bool}).
+#     '''
+#     i = _MODS.inspect
+#     try:
+#         a = k = 0
+#         for _, p in i.signature(func).parameters.items():
+#             if p.kind is p.POSITIONAL_OR_KEYWORD:
+#                 if p.default is p.empty:
+#                     a += 1
+#                 else:
+#                     k += 1
+#     except AttributeError:  # Python 2-
+#         s = i.getargspec(func)
+#         k = len(s.defaults or ())
+#         a = len(s.args) - k
+#     if exelf and a > 0 and i.ismethod(func):
+#         a -= 1
+#     return a, k
 
 
 def _args_kwds_names(func, splast=False):
@@ -222,7 +222,7 @@ def halfs2(str2):
     return str2[:h], str2[h:]
 
 
-def int1s(x):
+def int1s(x):  # PYCHOK no cover
     '''Count the number of 1-bits in an C{int}, I{unsigned}.
 
        @note: C{int1s(-B{x}) == int1s(abs(B{x}))}.
@@ -736,7 +736,7 @@ def _xcopy(obj, deep=False):
     return _deepcopy(obj) if deep else _copy(obj)
 
 
-def _xcoverage(where, *required):
+def _xcoverage(where, *required):  # in .__main__  # PYCHOK no cover
     '''(INTERNAL) Import C{coverage} and check required version.
     '''
     try:
@@ -847,15 +847,16 @@ def _xor(x, *xs):
     return x
 
 
-def _xpackages(_xpkg):
+def _xpackages(_xpkgf):
     '''(INTERNAL) Check dependency to be excluded.
     '''
-    n = _xpkg.__name__[2:]  # _DUNDER_nameof, less '_x'
-    if n in _XPACKAGES:  # n.lower() in _XPACKAGES
-        E = _PYGEODESY(_xpackages)
-        x = _SPACE_(n, _in_, E)
-        e = _enquote(_getenv(E, NN))
-        raise ImportError(_EQUAL_(x, e))
+    if _XPACKAGES:  # PYCHOK no cover
+        n = _xpkgf.__name__[2:]  # _DUNDER_nameof, less '_x'
+        if n.lower() in _XPACKAGES:
+            E = _PYGEODESY(_xpackages)
+            x = _SPACE_(n, _in_, E)
+            e = _enquote(_getenv(E, NN))
+            raise ImportError(_EQUAL_(x, e))
 
 
 def _xscalar(**names_values):
@@ -933,7 +934,7 @@ _XPACKAGES = _splituple(_getenv(_PYGEODESY(_xpackages), NN).lower())  # test/bas
 
 # **) MIT License
 #
-# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),

pygeodesy/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)
 
 
@@ -1982,7 +1982,7 @@ __all__ += _ALL_DOCS(_BooleanBase, _Clip,
 
 # **) MIT License
 #
-# Copyright (C) 2018-2024 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2018-2025 -- mrJean1 at Gmail -- All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),