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

pygeodesy/units.py

@@ -27,7 +27,7 @@ from pygeodesy.unitsBase import Float, Int, _NamedUnit, Radius, Str,  Fmt, fstr
 from math import degrees, isnan, radians
 
 __all__ = _ALL_LAZY.units
-__version__ = '24.10.12'
+__version__ = '24.11.06'
 
 
 class Float_(Float):
@@ -527,7 +527,7 @@ class FIx(Float_):
                         (C{bool}) or C{None} for backward compatible L{LatLon2Tuple} or
                         B{C{LatLon}} with I{averaged} lat- and longitudes.
            @kwarg LatLon_or_Vector_and_kwds: Optional C{B{LatLon}=None} I{or} C{B{Vector}=None}
-                         to return the I{intermediate}, I{fractional} point and optional,
+                         to return the I{intermediate}, I{fractional} point and optionally,
                          additional B{C{LatLon}} I{or} B{C{Vector}} keyword arguments, see
                          function L{fractional<pygeodesy.points.fractional>}.
 

pygeodesy/utm.py

@@ -39,7 +39,7 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  _under
 from pygeodesy.dms import degDMS, parseDMS2
 from pygeodesy.errors import MGRSError, RangeError, _ValueError, \
                             _xkwds_get, _xkwds_pop2
-from pygeodesy.fmath import fdot3, hypot, hypot1,  _operator
+from pygeodesy.fmath import fdot_, fdot3, hypot, hypot1,  _operator
 # from pygeodesy.internals import _under  # from .datums
 from pygeodesy.interns import MISSING, NN, _by_, _COMMASPACE_, _N_, \
                              _NS_, _outside_, _range_, _S_, _scale0_, \
@@ -63,7 +63,7 @@ from math import asinh, atanh, atan2, cos, cosh, degrees, fabs, \
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.utm
-__version__ = '24.10.12'
+__version__ = '24.11.07'
 
 _Bands = 'CDEFGHJKLMNPQRSTUVWXX'  # UTM latitude bands C..X (no
 # I|O) 8° each, covering 80°S to 84°N and X repeated for 80-84°N
@@ -566,12 +566,12 @@ def toUtm8(latlon, lon=None, datum=None, Utm=Utm, falsed=True,
     # easting, northing: Karney 2011 Eq 7-14, 29, 35
     sb, cb = sincos2(b)
 
-    T = tan(a)
+    T   = tan(a)
     T12 = hypot1(T)
-    S = sinh(E.e * atanh(E.e * T / T12))
+    S   = sinh(E.e * atanh(E.e * T / T12))
 
-    T_ = T * hypot1(S) - S * T12
-    H = hypot(T_, cb)
+    T_ = fdot_(T, hypot1(S), -S, T12)
+    H  = hypot(T_, cb)
 
     y = atan2(T_, cb)  # ξ' ksi
     x = asinh(sb / H)  # η' eta

pygeodesy/vector2d.py

@@ -12,7 +12,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, hypot, hypot2_, sqrt
+from pygeodesy.fmath import fabs, fdot, fdot_, hypot, hypot2_, sqrt
 from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1f_
 from pygeodesy.interns import NN, _a_, _and_, _b_, _c_, _center_, _coincident_, \
                              _colinear_, _COMMASPACE_, _concentric_, _few_, \
@@ -31,7 +31,7 @@ from contextlib import contextmanager
 # from math import fabs, sqrt  # from .fmath
 
 __all__ = _ALL_LAZY.vector2d
-__version__ = '24.08.19'
+__version__ = '24.11.10'
 
 _cA_        = 'cA'
 _cB_        = 'cB'
@@ -175,7 +175,7 @@ def _circin6(point1, point2, point3, eps=EPS4, useZ=True, dLL3=False, **Vector_k
         C = V(c.x, c.y, c.z, **V_kwds)
         return c, C
 
-    t, p1, p2, p3 = _radii11ABC(point1, point2, point3, useZ=useZ)
+    t, p1, p2, p3 = _radii11ABC4(point1, point2, point3, useZ=useZ)
     V, r1, r2, r3 =  point1.classof, t.rA, t.rB, t.rC
 
     c1, cA = _contact2(t.a, p2, r2, p3, r3, V, _xkwds(Vector_kwds, name=_cA_))
@@ -251,8 +251,8 @@ def circum4(points, useZ=True, **Vector_and_kwds):
        @kwarg useZ: If C{True}, use the points' Z component, otherwise force C{z=INT0}
                     (C{bool}).
        @kwarg Vector_and_kwds: Optional class C{B{Vector}=None} to return the center point
-                     and optional, additional B{C{Vector}} keyword arguments, otherwise
-                     the first B{C{points}}' (sub-)class is used.
+                     and optionally, additional B{C{Vector}} keyword arguments, otherwise
+                     the B{C{points}}' (sub-)class.
 
        @return: L{Circum4Tuple}C{(radius, center, rank, residuals)} with C{center} an
                 instance of C{B{points}[0]}' (sub-)class or B{C{Vector}} if specified.
@@ -509,12 +509,12 @@ def radii11(point1, point2, point3, useZ=True):
              U{Tangent Circles<https://MathWorld.Wolfram.com/TangentCircles.html>}.
     '''
     try:
-        return _radii11ABC(point1, point2, point3, useZ=useZ)[0]
+        return _radii11ABC4(point1, point2, point3, useZ=useZ)[0]
     except (TypeError, ValueError) as x:
         raise _xError(x, point1=point1, point2=point2, point3=point3)
 
 
-def _radii11ABC(point1, point2, point3, useZ=True):
+def _radii11ABC4(point1, point2, point3, useZ=True):
     # (INTERNAL) Tangent, Circum, Incircle, Soddy radii, sides and semi-perimeter
     A = _otherV3d(useZ=useZ, point1=point1, NN_OK=False)
     B = _otherV3d(useZ=useZ, point2=point2, NN_OK=False)
@@ -589,7 +589,7 @@ def soddy4(point1, point2, point3, eps=EPS4, useZ=True):
        @see: Functions L{radii11} and L{circum3} and U{Soddy Circles
              <https://MathWorld.Wolfram.com/SoddyCircles.html>}.
     '''
-    t, p1, p2, p3 = _radii11ABC(point1, point2, point3, useZ=useZ)
+    t, p1, p2, p3 = _radii11ABC4(point1, point2, point3, useZ=useZ)
 
     r    =  t.riS
     c, d = _tricenter3d2(p1, t.rA + r,
@@ -685,8 +685,8 @@ def trilaterate2d2(x1, y1, radius1, x2, y2, radius2, x3, y3, radius3,
        @kwarg eps: Tolerance to check the trilaterated point I{delta} on
                    all 3 circles (C{scalar}) or C{None} for no checking.
        @kwarg Vector_and_kwds: Optional class C{B{Vector}=None} to return
-                               the trilateration and optional, additional
-                               B{C{Vector}} keyword arguments).
+                     the trilateration and optionally, additional B{C{Vector}}
+                     keyword arguments).
 
        @return: Trilaterated point as C{B{Vector}(x, y, **B{Vector_kwds})}
                 or L{Vector2Tuple}C{(x, y)} if C{B{Vector} is None}.
@@ -742,14 +742,14 @@ def _trilaterate2d2(x1, y1, radius1, x2, y2, radius2, x3, y3, radius3,
         raise IntersectionError(_and(_astr(x3=x3, y3=y3, radius3=r3),
                                      _astr(x1=x1, y1=y1, radius1=r1)), txt=t)
 
-    q = (a * e - b * d) * _2_0
+    q = fdot_(a, e, -b, d) * _2_0
     if isnear0(q):
         t = _no_(_intersection_)
         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((c * e - b * f) / q,
-                     (a * f - c * d) / q, name=trilaterate2d2.__name__)
+    t = Vector2Tuple(fdot_(c, e, -b, f) / q,
+                     fdot_(a, f, -c, d) / q, name=trilaterate2d2.__name__)
 
     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)):

pygeodesy/vector3d.py

@@ -31,7 +31,7 @@ from pygeodesy.vector3dBase import Vector3dBase
 # from math import fabs, sqrt  # from .fmath
 
 __all__ = _ALL_LAZY.vector3d
-__version__ = '24.10.01'
+__version__ = '24.11.11'
 
 _vector2d = _MODS.into(vector2d=__name__)
 
@@ -272,7 +272,7 @@ class Vector3d(Vector3dBase):
                  Circles<https://MathWorld.Wolfram.com/TangentCircles.html>}.
         '''
         try:
-            return _vector2d._radii11ABC(self, point2, point3, useZ=True)[0]
+            return _vector2d._radii11ABC4(self, point2, point3, useZ=True)[0]
         except (TypeError, ValueError) as x:
             raise _xError(x, point=self, point2=point2, point3=point3)
 
@@ -497,17 +497,16 @@ def intersection3d3(start1, end1, start2, end2, eps=EPS, useZ=True,
                   B{C{start2}} (Ccompass C{degrees}).
        @kwarg eps: Tolerance for skew line distance and length (C{EPS}).
        @kwarg useZ: If C{True}, use the Z components, otherwise force C{z=INT0} (C{bool}).
-       @kwarg Vector_and_kwds: Optional class C{B{Vector}=None} to return the
-                               intersection points and optional, additional B{C{Vector}}
-                               keyword arguments, otherwise B{C{start1}}'s (sub-)class.
+       @kwarg Vector_and_kwds: Optional class C{B{Vector}=None} to return the intersection
+                     points and optional, additional B{C{Vector}} keyword arguments,
+                     otherwise B{C{start1}}'s (sub-)class.
 
-       @return: An L{Intersection3Tuple}C{(point, outside1, outside2)} with
-                C{point} an instance of B{C{Vector}} or B{C{start1}}'s (sub-)class.
+       @return: An L{Intersection3Tuple}C{(point, outside1, outside2)} with C{point}
+                an instance of B{C{Vector}} or B{C{start1}}'s (sub-)class.
 
        @note: The C{outside} values is C{0} for lines specified by point and bearing.
 
-       @raise IntersectionError: Invalid, skew, non-co-planar or otherwise
-                                 non-intersecting lines.
+       @raise IntersectionError: Invalid, skew, non-co-planar or otherwise non-intersecting lines.
 
        @see: U{Line-line intersection<https://MathWorld.Wolfram.com/Line-LineIntersection.html>}
              and U{line-line distance<https://MathWorld.Wolfram.com/Line-LineDistance.html>},
@@ -538,9 +537,9 @@ def intersections2(center1, radius1, center2, radius2, sphere=True, **Vector_and
        @kwarg sphere: If C{True}, compute the center and radius of the intersection of
                       two spheres.  If C{False}, ignore the C{z}-component and compute
                       the intersection of two circles (C{bool}).
-       @kwarg Vector_and_kwds: Optional class C{B{Vector}=None} to return the
-                               intersection points and optional, additional B{C{Vector}}
-                               keyword arguments, otherwise B{C{center1}}'s (sub-)class.
+       @kwarg Vector_and_kwds: Optional class C{B{Vector}=None} to return the intersection
+                     points and optionally, additional B{C{Vector}} keyword arguments,
+                     otherwise B{C{center1}}'s (sub-)class.
 
        @return: If C{B{sphere} is True}, a 2-tuple of the C{center} and C{radius} of the
                 intersection of the I{spheres}.  For abutting circles, C{radius} is C{0.0}
@@ -725,12 +724,12 @@ def nearestOn6(point, points, closed=False, useZ=True, **Vector_and_kwds):  # ep
        @kwarg closed: Optionally, close the path or polygon (C{bool}).
        @kwarg useZ: If C{True}, use the Z components, otherwise force C{z=INT0} (C{bool}).
        @kwarg Vector_and_kwds: Optional class C{B{Vector}=None} to return the closest
-                               point and optional, additional B{C{Vector}} keyword
-                               arguments, otherwise B{C{point}}'s (sub-)class.
+                     point and optionally, additional B{C{Vector}} keyword arguments,
+                     otherwise B{C{point}}'s (sub-)class.
 
        @return: A L{NearestOn6Tuple}C{(closest, distance, fi, j, start, end)} with the
                 C{closest}, the C{start} and the C{end} point each an instance of the
-                B{C{Vector}} keyword argument of if {B{Vector}=None} or not specified,
+                B{C{Vector}} keyword argument or if {B{Vector}=None} or not specified,
                 an instance of the reference B{C{point}}'s (sub-)class.
 
        @raise PointsError: Insufficient number of B{C{points}}
@@ -854,17 +853,16 @@ def trilaterate3d2(center1, radius1, center2, radius2, center3, radius3,
                      and C{z}).
        @kwarg eps: Pertubation tolerance (C{scalar}), same units as C{x},
                    C{y} and C{z} or C{None} for no pertubations.
-       @kwarg Vector_and_kwds: Optional class C{B{Vector}=None} to return
-                               the trilateration and optional, additional
-                               B{C{Vector}} keyword arguments, otherwise
-                               the B{C{center1}}'s (sub-)class.
+       @kwarg Vector_and_kwds: Optional class C{B{Vector}=None} to return the
+                     trilateration and optionally, additional B{C{Vector}}
+                     keyword arguments, otherwise B{C{center1}}'s (sub-)class.
 
        @return: 2-Tuple with two trilaterated points, each a B{C{Vector}}
                 instance.  Both points are the same instance if all three
                 spheres abut/intersect in a single point.
 
-       @raise ImportError: Package C{numpy} not found, not installed or
-                           older than version 1.10.
+       @raise ImportError: Package C{numpy} not found, not installed or older
+                           than version 1.10.
 
        @raise IntersectionError: Near-concentric, -colinear, too distant or
                                  non-intersecting spheres.

pygeodesy/vector3dBase.py

@@ -14,7 +14,7 @@ from pygeodesy.constants import EPS, EPS0, INT0, PI, PI2, _copysignINF, \
                                _float0, isnear0, isnear1, isneg0, \
                                _pos_self, _1_0
 from pygeodesy.errors import CrossError, VectorError, _xcallable, _xError
-from pygeodesy.fmath import euclid_, fdot, hypot_, hypot2_
+from pygeodesy.fmath import euclid_, fdot, fdot_, hypot_, hypot2_  # _MODS.fmath.fma
 from pygeodesy.interns import _coincident_, _colinear_, _COMMASPACE_, _xyz_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_DOCS, _ALL_MODS as _MODS
 from pygeodesy.named import _NamedBase, _NotImplemented, _xother3
@@ -28,7 +28,7 @@ from pygeodesy.utily import sincos2,  atan2, fabs
 from math import ceil as _ceil, floor as _floor, trunc as _trunc
 
 __all__ = _ALL_LAZY.vector3dBase
-__version__ = '24.10.12'
+__version__ = '24.11.10'
 
 
 class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
@@ -141,10 +141,6 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
         '''Not implemented.'''
         return _NotImplemented(self, other)
 
-    def __format__(self, *other):  # PYCHOK no cover
-        '''Not implemented.'''
-        return _NotImplemented(self, *other)
-
     def __ge__(self, other):
         '''Is this vector longer than or equal to an other vector?
 
@@ -504,9 +500,9 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
         '''
         X, Y, Z = self.others(other).xyz3
         x, y, z = self.xyz3
-        xyz = ((y * Z - z * Y),
-               (z * X - x * Z),
-               (x * Y - y * X))
+        xyz = (fdot_(y, Z, -z, Y),
+               fdot_(z, X, -x, Z),
+               fdot_(x, Y, -y, X))
 
         if raiser and self.crosserrors and eps0 > 0 \
                   and max(map(fabs, xyz)) < eps0:
@@ -823,11 +819,12 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
         '''
         return self._plus(*_xyz3(self.plus_, other_x, *y_z))
 
-    def rotate(self, axis, theta):
+    def rotate(self, axis, theta, fma=False):
         '''Rotate this vector around an axis by a specified angle.
 
            @arg axis: The axis being rotated around (L{Vector3d}).
            @arg theta: The angle of rotation (C{radians}).
+           @kwarg fma: If C{True}, use fused-multiply-add (C{bool}).
 
            @return: New, rotated vector (L{Vector3d}).
 
@@ -846,17 +843,23 @@ class Vector3dBase(_NamedBase):  # sync __methods__ with .fsums.Fsum
             bx, by, bz = r.times(d).xyz3
             sx, sy, sz = r.times(s).xyz3
 
-            x = fdot(p, ax * bx + c,  ax * by - sz, ax * bz + sy)
-            y = fdot(p, ay * bx + sz, ay * by + c,  ay * bz - sx)
-            z = fdot(p, az * bx - sy, az * by + sx, az * bz + c)
+            if fma:
+                _fma = _MODS.fmath.fma
+            else:
+                def _fma(a, b, c):
+                    return a * b + c
+
+            x = fdot(p, _fma(ax, bx,   c), _fma(ax, by, -sz), _fma(ax, bz,  sy))
+            y = fdot(p, _fma(ay, bx,  sz), _fma(ay, by,   c), _fma(ay, bz, -sx))
+            z = fdot(p, _fma(az, bx, -sy), _fma(az, by,  sx), _fma(az, bz,   c))
         else:  # unrotated
             x, y, z = self.xyz3
         return self.classof(x, y, z)
 
     @deprecated_method
-    def rotateAround(self, axis, theta):  # PYCHOK no cover
+    def rotateAround(self, axis, theta):
         '''DEPRECATED, use method C{rotate}.'''
-        return self.rotate(axis, theta)
+        return self.rotate(axis, theta)  # PYCHOK no cover
 
     def times(self, factor):
         '''Multiply this vector by a scalar.

pygeodesy/webmercator.py

@@ -36,7 +36,7 @@ from pygeodesy.utily import degrees90, degrees180
 from math import atan, atanh, exp, radians, sin, tanh
 
 __all__ = _ALL_LAZY.webmercator
-__version__ = '24.08.13'
+__version__ = '24.11.06'
 
 # _FalseEasting  = 0   # false Easting (C{meter})
 # _FalseNorthing = 0   # false Northing (C{meter})
@@ -314,10 +314,10 @@ def toWm(latlon, lon=None, earth=R_MA, Wm=Wm, **name_Wm_kwds_radius):
                      L{a_f2Tuple}, L{Ellipsoid} or L{Ellipsoid2}), overridden
                      by B{C{latlon}}'s datum if present.
        @kwarg Wm: Optional class to return the WM coordinate (L{Wm}) or C{None}.
-       @kwarg name_Wm_kwds_radius: Optional C{B{name}=NN} (C{str}), optional,
+       @kwarg name_Wm_kwds_radius: Optional C{B{name}=NN} (C{str}), optionally,
                    additional B{C{Wm}} keyword arguments, ignored if C{B{Wm} is
-                   None} and DEPRECATED keyword argument C{B{radius}=earth},
-                   use B{C{earth}}.
+                   None} and DEPRECATED keyword argument C{B{radius}=earth}, use
+                   B{C{earth}}.
 
        @return: The WM coordinate (B{C{Wm}}) or if C{B{Wm} is None}, an
                 L{EasNorRadius3Tuple}C{(easting, northing, radius)}.

pygeodesy/wgrs.py

@@ -32,7 +32,7 @@ from pygeodesy.utily import ft2m, m2ft, m2NM
 from math import floor
 
 __all__ = _ALL_LAZY.wgrs
-__version__ = '24.08.15'
+__version__ = '24.11.06'
 
 _Base    =  10
 _BaseLen =  4
@@ -212,9 +212,9 @@ class Georef(Str):
 
            @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
            @kwarg height: Optional height (C{meter}), overriding this height.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{LatLon}} keyword arguments, ignored if
-                       C{B{LatLon} is None}.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{LatLon}} keyword arguments, ignored if C{B{LatLon}
+                       is None}.
 
            @return: This georef location (B{C{LatLon}}) or if C{B{LatLon} is None},
                     a L{LatLon3Tuple}C{(lat, lon, height)}.