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

pygeodesy/__init__.py

@@ -1,11 +1,11 @@
 
 # -*- coding: utf-8 -*-
 
-u'''A pure Python implementation of geodesy tools for various ellipsoidal and spherical earth
-models using precision exact, elliptic, trigonometric, vector-based, iterative and approximate
-methods for geodetic (lat-/longitude), geocentric (U{ECEF<https://WikiPedia.org/wiki/ECEF>}
-cartesian) and certain U{triaxial ellipsoidal<https://GeographicLib.SourceForge.io/1.44/triaxial.html>}
-coordinates.
+u'''A pure Python implementation of geodesy tools for various ellipsoidal and spherical earth models
+using precision exact, elliptic, trigonometric, vector-based, iterative and approximate methods for
+geodetic (lat-/longitude), geocentric (U{ECEF<https://WikiPedia.org/wiki/ECEF>} cartesian), local (U{LTP
+<https://WikiPedia.org/wiki/Local_tangent_plane_coordinates>}) and certain U{triaxial ellipsoidal
+<https://GeographicLib.SourceForge.io/1.44/triaxial.html>} coordinates.
 
 Transcoded in part from U{JavaScript originals<https://GitHub.com/ChrisVeness/geodesy>} by I{Chris Veness (C)
 2005-2024} and from several U{C++ classes<https://GeographicLib.SourceForge.io/C++/doc/annotated.html>} by I{Charles
@@ -406,6 +406,7 @@ if _init__all__ and not _lazy_import2:  # import and set __all__
     import pygeodesy.deprecated            as deprecated             # PYCHOK exported
     import pygeodesy.dms                   as dms                    # PYCHOK exported
     import pygeodesy.ecef                  as ecef                   # PYCHOK exported
+    import pygeodesy.ecefLocals            as ecefLocals             # PYCHOK exported
     import pygeodesy.elevations            as elevations             # PYCHOK exported
     import pygeodesy.ellipsoidalBase       as ellipsoidalBase        # PYCHOK INTERNAL
     import pygeodesy.ellipsoidalBaseDI     as ellipsoidalBaseDI      # PYCHOK INTERNAL
@@ -491,6 +492,7 @@ if _init__all__ and not _lazy_import2:  # import and set __all__
     from pygeodesy.deprecated            import *  # PYCHOK __all__ DEPRECATED
     from pygeodesy.dms                   import *  # PYCHOK __all__
     from pygeodesy.ecef                  import *  # PYCHOK __all__
+#   from pygeodesy.ecefLocals            import *  # PYCHOK __all__
     from pygeodesy.elevations            import *  # PYCHOK __all__
 #   from pygeodesy.ellipsoidalBase       import *  # PYCHOK __(_)__ INTERNAL
 #   from pygeodesy.ellipsoidalBaseDI     import *  # PYCHOK __(_)__ INTERNAL
@@ -602,7 +604,7 @@ else:
 
 from pygeodesy.internals import _version2,  _DOT_  # PYCHOK import
 # from pygeodesy.interns import _DOT_  # from .internals
-__version__ = '25.04.25'
+__version__ = '25.05.05'
 # see setup.py for similar logic
 version     = _DOT_(*_version2(__version__, n=3))
 

pygeodesy/basics.py

@@ -616,7 +616,7 @@ def map1(fun1, *xs):  # XXX map_
 
        @return: Function results (C{tuple}).
     '''
-    return tuple(map(fun1, xs))
+    return tuple(map(fun1, xs))  # if len(xs) != 1 else fun1(xs[0])
 
 
 def map2(fun, *xs, **strict):

pygeodesy/booleans.py

@@ -22,7 +22,7 @@ from pygeodesy.basics import _isin, isodd, issubclassof, map2, \
 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, fdot_, hypot, hypot2
+from pygeodesy.fmath import favg, Fdot_, fdot_, hypot, hypot2
 # from pygeodesy.fsums import fsum1  # _MODS
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _BANG_, _clipid_, _COMMASPACE_, \
@@ -45,7 +45,7 @@ from pygeodesy.utily import fabs, _unrollon, _Wrap
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.booleans
-__version__ = '25.04.14'
+__version__ = '25.04.30'
 
 _0EPS  =  EPS  # near-zero, positive
 _EPS0  = -EPS  # near-zero, negative
@@ -1612,8 +1612,8 @@ class _EdgeGH(object):
 
     def _alpha2(self, x, y, dx, dy):
         # Return C{(alpha)}, see .points.nearestOn5
-        a = fdot_(y, dy,  x, dx) / self._hypot2
-        d = fdot_(y, dx, -x, dy) / self._hypot0
+        a = Fdot_(y, dy,  x, dx).fover(self._hypot2)
+        d = Fdot_(y, dx, -x, dy).fover(self._hypot0)
         return a, fabs(d)
 
     def _Error(self, n, *args, **kwds):  # PYCHOK no cover
@@ -1655,10 +1655,10 @@ class _EdgeGH(object):
             if fabs(d) > _0EPS:  # non-parallel edges
                 dx = x - c1_x
                 dy = y - c1_y
-                ca = fdot_(sx, dy, -sy, dx) / d
+                ca = Fdot_(sx, dy, -sy, dx).fover(d)
                 if _0EPS < ca < _EPS1 or (self._xtend and
                    _EPS0 < ca < _1EPS):
-                    sa = fdot_(cx, dy, -cy, dx) / d
+                    sa = Fdot_(cx, dy, -cy, dx).fover(d)
                     if _0EPS < sa < _EPS1 or (self._xtend and
                        _EPS0 < sa < _1EPS):
                         yield (y + sa * sy), (x + sa * sx), sa, ca
@@ -1669,7 +1669,7 @@ class _EdgeGH(object):
 
                 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 = fdot_(cx, dy, -cy, dx) / d
+                    sa = Fdot_(cx, dy, -cy, dx).fover(d)
                     e  = 2 if sa < _EPS0 or sa > _1EPS else 3
                     raise self._Error(e, c1, c2, ca=ca)
 

pygeodesy/cartesianBase.py

@@ -16,6 +16,7 @@ from pygeodesy.constants import EPS, EPS0, INT0, PI2, _isfinite, isnear0, \
 from pygeodesy.datums import Datum, _earth_ellipsoid, _spherical_datum, \
                              Transform, _WGS84
 # from pygeodesy.ecef import EcefKarney  # _MODS
+from pygeodesy.ecefLocals import _EcefLocal
 from pygeodesy.errors import _IsnotError, _TypeError, _ValueError, _xattr, \
                              _xdatum, _xkwds, _xkwds_get, _xkwds_pop2
 from pygeodesy.fmath import cbrt, hypot, hypot_, hypot2,  fabs, sqrt  # hypot
@@ -25,7 +26,7 @@ from pygeodesy.fsums import fsumf_,  Fmt
 from pygeodesy.interns import _COMMASPACE_, _datum_, _no_, _phi_
 from pygeodesy.interns import _ellipsoidal_, _spherical_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _name2__, _NamedLocal, _Pass
+from pygeodesy.named import _name2__, _Pass
 from pygeodesy.namedTuples import LatLon4Tuple, _NamedTupleTo , Vector3Tuple, \
                                   Vector4Tuple,  Bearing2Tuple  # PYCHOK .sphericalBase
 # from pygeodesy.nvectorBase import _N_vector  # _MODS
@@ -43,14 +44,14 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 # from math import degrees, fabs, radians, sqrt  # from .fmath, .utily
 
 __all__ = _ALL_LAZY.cartesianBase
-__version__ = '25.04.21'
+__version__ = '25.04.28'
 
 _r_         = 'r'
 _resections = _MODS.into(resections=__name__)
 _theta_     = 'theta'
 
 
-class CartesianBase(Vector3d, _NamedLocal):
+class CartesianBase(Vector3d, _EcefLocal):
     '''(INTERNAL) Base class for ellipsoidal and spherical C{Cartesian}.
     '''
     _datum  = None  # L{Datum}, to be overriden
@@ -200,7 +201,7 @@ class CartesianBase(Vector3d, _NamedLocal):
         '''
         n, kwds = _name2__(name_Cartesian_kwds, _or_nameof=self)
         if Cartesian is None:
-            r = self._Ltp._local2ecef(delta, nine=True)
+            r = self._ltp._local2ecef(delta, nine=True)  # _EcefLocal._ltp
         else:
             d = self.datum
             if not d:
@@ -208,7 +209,7 @@ class CartesianBase(Vector3d, _NamedLocal):
             t = _xkwds_get(kwds, datum=d)
             if _xattr(t, ellipsoid=None) != d.ellipsoid:
                 raise _TypeError(datum=t, txt=str(d))
-            c = self._Ltp._local2ecef(delta, nine=False)
+            c = self._ltp._local2ecef(delta, nine=False)  # _EcefLocal._ltp
             r = Cartesian(*c, **kwds)
         return r.renamed(n) if n else r
 

pygeodesy/ecef.py

@@ -63,19 +63,19 @@ from pygeodesy.constants import EPS, EPS0, EPS02, EPS1, EPS2, EPS_2, INT0, PI, P
                                _0_0, _0_0001, _0_01, _0_5, _1_0, _1_0_1T, _N_1_0, \
                                _2_0, _N_2_0, _3_0, _4_0, _6_0, _60_0, _90_0, _N_90_0, \
                                _100_0, _copysign_1_0,  isnon0  # PYCHOK used!
-from pygeodesy.datums import a_f2Tuple, _ellipsoidal_datum, _WGS84,  _EWGS84
+from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  a_f2Tuple, _EWGS84
+from pygeodesy.ecefLocals import _EcefLocal
 # from pygeodesy.ellipsoids import a_f2Tuple, _EWGS84  # from .datums
 from pygeodesy.errors import _IndexError, LenError, _ValueError, _TypesError, \
                              _xattr, _xdatum, _xkwds, _xkwds_get
-from pygeodesy.fmath import cbrt, fdot, Fpowers, hypot, hypot1, hypot2_, sqrt0
+from pygeodesy.fmath import cbrt, fdot, hypot, hypot1, hypot2_, sqrt0
 from pygeodesy.fsums import Fsum, fsumf_,  Fmt, unstr
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _a_, _C_, _datum_, _ellipsoid_, _f_, _height_, \
                              _lat_, _lon_, _M_, _name_, _singular_, _SPACE_, \
                              _x_, _xyz_, _y_, _z_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _name__, _name1__, _NamedBase, _NamedLocal, \
-                            _NamedTuple, _Pass, _xnamed
+from pygeodesy.named import _name__, _name1__, _NamedBase, _NamedTuple, _Pass, _xnamed
 from pygeodesy.namedTuples import LatLon2Tuple, LatLon3Tuple, \
                                   PhiLam2Tuple, Vector3Tuple, Vector4Tuple
 from pygeodesy.props import deprecated_method, Property_RO, property_RO, \
@@ -90,7 +90,7 @@ from pygeodesy.utily import atan1, atan1d, atan2, atan2d, degrees90, degrees180,
 from math import cos, degrees, fabs, radians, sqrt
 
 __all__ = _ALL_LAZY.ecef
-__version__ = '25.04.24'
+__version__ = '25.04.28'
 
 _Ecef_    = 'Ecef'
 _prolate_ = 'prolate'
@@ -110,6 +110,7 @@ class _EcefBase(_NamedBase):
     '''
     _datum = _WGS84
     _E     = _EWGS84
+    _isYou =  False
     _lon00 =  INT0  # arbitrary, "polar" lon for LocalCartesian, Ltp
 
     def __init__(self, a_ellipsoid=_EWGS84, f=None, lon00=INT0, **name):
@@ -272,12 +273,6 @@ class _EcefBase(_NamedBase):
         return (Ecef9Tuple,  # overwrite property_ROver
                _MODS.vector3d.Vector3d)  # _MODS.cartesianBase.CartesianBase
 
-    @Property_RO
-    def _isYou(self):
-        '''(INTERNAL) Is this an C{EcefYou}?.
-        '''
-        return isinstance(self, EcefYou)
-
     @property
     def lon00(self):
         '''Get the I{"polar"} longitude (C{degrees}), see method C{reverse}.
@@ -790,6 +785,7 @@ class EcefYou(_EcefBase):
              11589/115114_9021_geod2ellip_final.pdf>} Studia Geophysica et Geodaetica, 2008, 52,
              pages 1-18 and U{PyMap3D <https://PyPI.org/project/pymap3d>}.
     '''
+    _isYou = True
 
     def __init__(self, a_ellipsoid=_EWGS84, f=None, **lon00_name):  # PYCHOK signature
         _EcefBase.__init__(self, a_ellipsoid, f=f, **lon00_name)  # inherited documentation
@@ -825,13 +821,14 @@ class EcefYou(_EcefBase):
                              ellipsoid is I{prolate}.
         '''
         x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **lon00_name)
+        q = hypot(x, y)  # R
 
         E = self.ellipsoid
         e, e2 = self._ee2
 
-        q = hypot(x, y)  # R
-        u = Fpowers(2, x, y, z) - e2
-        u = u.fadd_(hypot(u, e * z * _2_0)).fover(_2_0)
+        u  =  hypot2_(x, y, z) - e2
+        u +=  hypot(u, e * z * _2_0)
+        u *= _0_5
         if u > EPS02:
             u = sqrt(u)
             p = hypot(u, e)
@@ -1019,7 +1016,7 @@ class EcefMatrix(_NamedTuple):
         return xyz_
 
 
-class Ecef9Tuple(_NamedTuple, _NamedLocal):
+class Ecef9Tuple(_NamedTuple, _EcefLocal):
     '''9-Tuple C{(x, y, z, lat, lon, height, C, M, datum)} with I{geocentric} C{x},
        C{y} and C{z} plus I{geodetic} C{lat}, C{lon} and C{height}, case C{C} (see
        the C{Ecef*.reverse} methods) and optionally, rotation matrix C{M} (L{EcefMatrix})
@@ -1041,7 +1038,7 @@ class Ecef9Tuple(_NamedTuple, _NamedLocal):
         return self.toDatum(datum2)
 
     @property_RO
-    def _ecef9(self):
+    def _ecef9(self):  # in ._EcefLocal._Ltp_ecef2local
         return self
 
     @Property_RO
@@ -1103,13 +1100,6 @@ class Ecef9Tuple(_NamedTuple, _NamedLocal):
         '''
         return Lon(Vermeille=degrees(self.lamVermeille))
 
-    def _ltp_toLocal(self, ltp, Xyz_kwds, **Xyz):  # overloads C{_NamedLocal}'s
-        '''(INTERNAL) Invoke C{ltp._xLtp(ltp)._ecef2local}.
-        '''
-        Xyz_ = self._ltp_toLocal2(Xyz_kwds, **Xyz)  # in ._NamedLocal
-        ltp  = self._ltp._xLtp(ltp, self._Ltp)  # both in ._NamedLocal
-        return ltp._ecef2local(self, *Xyz_)
-
     @Property_RO
     def phi(self):
         '''Get the latitude in C{radians} (C{float}).

pygeodesy/ecefLocals.py

@@ -0,0 +1,186 @@
+
+# -*- coding: utf-8 -*-
+
+u'''(INTERNAL) ECEF to local coodinate conversions, separated from
+module C{ecef} to defer importing the latter into C{CartesianBase}
+and C{LatLonBase}.
+'''
+
+from pygeodesy.basics import _isin, _xsubclassof
+# from pygeodesy.ecef import EcefKarney  # _MODS
+from pygeodesy.errors import _xkwds_item2, _xkwds_pop2
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
+# from pygeodesy import ltp as _ltp  # _MODS.into
+# from pygeodesy import ltpTuples as _ltpTuples  # _MODS.into
+from pygeodesy.named import _Named, notOverloaded
+from pygeodesy.props import Property_RO, property_RO, property_ROver
+
+__all__ = _ALL_LAZY.ecefLocals
+__version__ = '25.04.28'
+
+_ltp       = _MODS.into(ltp=__name__)
+_ltpTuples = _MODS.into(ltpTuples=__name__)
+
+
+class _EcefLocal(_Named):
+    '''(INTERNAL) Base class for C{CartesianBase}, C{Ecef9Tuple} and
+       C{LatLonBase}, providing ECEF to local coordinate conversions.
+    '''
+
+    @property_ROver
+    def Ecef(self):
+        '''Get the ECEF I{class} (L{EcefKarney}), I{once}.
+        '''
+        return _MODS.ecef.EcefKarney
+
+    @property_RO
+    def _ecef9(self):
+        '''I{Must be overloaded}.'''
+        notOverloaded(self)
+
+    @property_RO
+    def _ecef9datum(self):
+        try:
+            d = self.datum  # PYCHOK C{CartesianBase}, ...
+        except AttributeError:
+            d = None
+        return d or self._ecef9.datum
+
+    @Property_RO
+    def _ltp(self):
+        '''(INTERNAL) Cache this instance' LTP (L{Ltp}).
+        '''
+        return _ltp.Ltp(self._ecef9, ecef=self.Ecef(self._ecef9datum), name=self.name)
+
+    def _ltp_ecef2local(self, ltp, Xyz_kwds, _None=None, **Xyz):  # in C{Ecef9Tuple}
+        '''(INTERNAL) Invoke C{_ltp._xLtp(ltp, self._ltp)._ecef2local}.
+        '''
+        C, _ = Xyz_ = _xkwds_pop2(Xyz_kwds, **Xyz)
+        if C is not _None:  # validate C, see .toLocal
+            n, X = _xkwds_item2(Xyz)
+            if X is not C:
+                _xsubclassof(X, **{n: C})
+        ltp = _ltp._xLtp(ltp, self._ltp)
+        return ltp._ecef2local(self._ecef9, *Xyz_)
+
+    def toAer(self, ltp=None, **Aer_and_kwds):
+        '''Convert this instance to I{local} I{Azimuth, Elevation, slant Range} (AER) components.
+
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       instance' L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Aer_and_kwds: Optional AER class C{B{Aer}=}L{Aer<pygeodesy.ltpTuples.Aer>}
+                      to use and optionally, additional B{C{Aer}} keyword arguments.
+
+           @return: An B{C{Aer}} instance.
+
+           @raise TypeError: Invalid B{C{ltp}}.
+
+           @see: Method L{toLocal<pygeodesy.ecefLocals._EcefLocal.toLocal>}.
+        '''
+        return self._ltp_ecef2local(ltp, Aer_and_kwds, Aer=_ltpTuples.Aer)
+
+    def toEnu(self, ltp=None, **Enu_and_kwds):
+        '''Convert this instance to I{local} I{East, North, Up} (ENU) components.
+
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       instance' L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Enu_and_kwds: Optional ENU class C{B{Enu}=}L{Enu<pygeodesy.ltpTuples.Enu>}
+                      to use and optionally, additional B{C{Enu}} keyword arguments.
+
+           @return: An B{C{Enu}} instance.
+
+           @raise TypeError: Invalid B{C{ltp}}.
+
+           @see: Method L{toLocal<pygeodesy.ecefLocals._EcefLocal.toLocal>}.
+        '''
+        return self._ltp_ecef2local(ltp, Enu_and_kwds, Enu=_ltpTuples.Enu)
+
+    def toLocal(self, Xyz=None, ltp=None, **Xyz_kwds):
+        '''Convert this instance to I{local} components in a I{local tangent plane} (LTP)
+
+           @kwarg Xyz: Optional I{local} components class (L{XyzLocal}, L{Aer}, L{Enu},
+                       L{Ned}) or C{None}.
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       cartesian's L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Xyz_kwds: Optionally, additional B{C{Xyz}} keyword arguments, ignored
+                            if C{B{Xyz} is None}.
+
+           @return: An B{C{Xyz}} instance or a L{Local9Tuple}C{(x, y, z, lat, lon,
+                    height, ltp, ecef, M)} if C{B{Xyz} is None} (with C{M=None}).
+
+           @raise TypeError: Invalid B{C{ltp}}.
+        '''
+        return self._ltp_ecef2local(ltp, Xyz_kwds, Xyz=Xyz, _None=Xyz)
+
+    def toLtp(self, Ecef=None, **name):
+        '''Return the I{local tangent plane} (LTP) for this instance.
+
+           @kwarg Ecef: Optional ECEF I{class} (L{EcefKarney}, ... L{EcefYou}), overriding
+                        this instance' L{Ecef<pygeodesy.ecefLocals._EcefLocal.Ecef>}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
+
+           @return: An B{C{Ltp}} instance.
+        '''
+        if _isin(Ecef, None, self.Ecef) and not name:
+            ltp = self._ltp
+        else:  # like self._ltp
+            ecef = (Ecef if Ecef else self.Ecef)(self._ecef9datum)
+            ltp  = _ltp.Ltp(self._ecef9, ecef=ecef, name=self._name__(name))
+        return ltp
+
+    def toNed(self, ltp=None, **Ned_and_kwds):
+        '''Convert this instance to I{local} I{North, East, Down} (NED) components.
+
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       instance' L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Ned_and_kwds: Optional NED class C{B{Ned}=}L{Ned<pygeodesy.ltpTuples.Ned>}
+                      to use and optionally, additional B{C{Ned}} keyword arguments.
+
+           @return: An B{C{Ned}} instance.
+
+           @raise TypeError: Invalid B{C{ltp}}.
+
+           @see: Method L{toLocal<pygeodesy.ecefLocals._EcefLocal.toLocal>}.
+        '''
+        return self._ltp_ecef2local(ltp, Ned_and_kwds, Ned=_ltpTuples.Ned)
+
+    def toXyz(self, ltp=None, **Xyz_and_kwds):
+        '''Convert this instance to I{local} I{X, Y, Z} (XYZ) components.
+
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       instance' L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Xyz_and_kwds: Optional XYZ class C{B{Xyz}=}L{Xyz<pygeodesy.ltpTuples.XyzLocal>}
+                      to use and optionally, additional B{C{Xyz}} keyword arguments.
+
+           @return: An B{C{Xyz}} instance.
+
+           @raise TypeError: Invalid B{C{ltp}}.
+
+           @see: Method L{toLocal<pygeodesy.ecefLocals._EcefLocal.toLocal>}.
+        '''
+        return self._ltp_ecef2local(ltp, Xyz_and_kwds, Xyz=_ltpTuples.XyzLocal)
+
+
+__all__ += _ALL_DOCS(_EcefLocal)
+
+# **) MIT License
+#
+# 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"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.

pygeodesy/ellipsoids.py

@@ -95,7 +95,7 @@ from pygeodesy.utily import atan1, atan1d, atan2b, degrees90, m2radians, radians
 from math import asinh, atan, atanh, cos, degrees, exp, fabs, radians, sin, sinh, sqrt, tan  # as _tan
 
 __all__ = _ALL_LAZY.ellipsoids
-__version__ = '25.04.23'
+__version__ = '25.04.28'
 
 _f_0_0    = Float(f =_0_0)  # zero flattening
 _f__0_0   = Float(f_=_0_0)  # zero inverse flattening
@@ -140,12 +140,14 @@ class a_f2Tuple(_NamedTuple):
            @arg f: Flattening (C{scalar} < 1, negative for I{prolate}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @return: An L{a_f2Tuple}C{(a, f)} instance.
+           @return: An L{a_f2Tuple}C{(a, f)}.
 
            @raise UnitError: Invalid B{C{a}} or B{C{f}}.
 
-           @note: C{abs(B{f}) < EPS} is forced to C{B{f}=0}, I{spherical}.
-                  Negative C{B{f}} produces a I{prolate} ellipsoid.
+           @note: C{abs(B{f}) < }L{EPS<pygeodesy.constants.EPS>} is
+                  forced to C{B{f}=0}, I{spherical}.
+
+           @note: Negative C{B{f}} produces a I{prolate} ellipsoid.
         '''
         a = Radius_(a=a)  # low=EPS, high=None
         f = Float_( f=f, low=None, high=EPS1)
@@ -359,11 +361,16 @@ class Ellipsoid(_NamedEnumItem):
         '''
         return a_f2Tuple(self.a, self.f, name=self.name)
 
+    a_f2 = a_f  # synonym
+
     @Property_RO
     def A(self):
         '''Get the UTM I{meridional (or rectifying)} radius (C{meter}).
 
-           @see: I{Meridian arc unit} U{Q<https://StudyLib.net/doc/7443565/>}.
+           @note: C{A * PI / 2} ≈= L{L<Ellipsoid.L>}, the I{quarter meridian}.
+
+           @see: I{Meridian arc unit} U{Q<https://StudyLib.net/doc/7443565/>},
+                 the mean, meridional length I{per radian}.
         '''
         A, n = self.a, self.n
         if n:
@@ -375,6 +382,11 @@ class Ellipsoid(_NamedEnumItem):
                 # A *= fhorner(n**2, 1048576, 262144, 16384, 4096, 1600, 784, 441) / 1048576) / (1 + n)
                 A = Radius(A=Fhorner(n**2, 1048576, 262144, 16384, 4096, 1600, 784, 441).fover(d))
         return A
+#       # Moritz, H. <https://Geodesy.Geology.Ohio-State.EDU/course/refpapers/00740128.pdf>
+#       # q =  4 / self.rocPolar
+#       # Q = (1 - 3 / 4 * e'2 + 45 / 64 * e'4 - 175 / 256 * e'6 + 11025 / 16384 * e'8) * rocPolar
+#       #   = (4 + e'2 * (-3 + e'2 * (45 / 16 + e'2 * (-175 / 64 + e'2 * 11025 / 4096)))) / q
+#       return Radius(Q=Fhorner(self.e22, 4, -3, 45 / 16, -175 / 64, 11025 / 4096).fover(q))
 
     @Property_RO
     def _albersCyl(self):
@@ -1339,23 +1351,7 @@ class Ellipsoid(_NamedEnumItem):
 
     polaradius = b  # Rpolar
 
-#   @Property_RO
-#   def Q(self):
-#       '''Get the I{meridian arc unit} C{Q}, the mean, meridional length I{per radian} C({float}).
-#
-#          @note: C{Q * PI / 2} ≈ C{L}, the I{quarter meridian}.
-#
-#          @see: Property C{A} and U{Engsager, K., Poder, K.<https://StudyLib.net/doc/7443565/
-#                a-highly-accurate-world-wide-algorithm-for-the-transverse...>}.
-#       '''
-#       n = self.n
-#       d = (n + _1_0) / self.a
-#       return Float(Q=Fhorner(n**2, _1_0, _0_25, _1_16th, _0_25).fover(d) if d else self.b)
-
-#       # Moritz, H. <https://Geodesy.Geology.Ohio-State.EDU/course/refpapers/00740128.pdf>
-#       # Q = (1 - 3/4 * e'2 + 45/64 * e'4 - 175/256 * e'6 + 11025/16384 * e'8) * rocPolar
-#       #   = (4 + e'2 * (-3 + e'2 * (45/16 + e'2 * (-175/64 + e'2 * 11025/4096)))) * rocPolar / 4
-#       return Fhorner(self.e22, 4, -3, 45 / 16, -175 / 64, 11025 / 4096).fover(4 / self.rocPolar)
+#   Q = A  # I{meridian arc unit} C{Q}, the mean, meridional length I{per radian}
 
     @deprecated_Property_RO
     def quarteradius(self):  # PYCHOK no cover
@@ -1382,16 +1378,13 @@ class Ellipsoid(_NamedEnumItem):
                  <https://WikiPedia.org/wiki/Earth_radius>}.
         '''
         return Radius(R2=sqrt(self.c2) if self.f else self.a)
-
-    Rauthalic = R2
-
-#   @Property_RO
-#   def R2(self):
 #       # Moritz, H. <https://Geodesy.Geology.Ohio-State.EDU/course/refpapers/00740128.pdf>
 #       # R2 = (1 - 2/3 * e'2 + 26/45 * e'4 - 100/189 * e'6 + 7034/14175 * e'8) * rocPolar
 #       #    = (3 + e'2 * (-2 + e'2 * (26/15 + e'2 * (-100/63 + e'2 * 7034/4725)))) * rocPolar / 3
 #       return Fhorner(self.e22, 3, -2, 26 / 15, -100 / 63, 7034 / 4725).fover(3 / self.rocPolar)
 
+    Rauthalic = R2
+
     @Property_RO
     def R2x(self):
         '''Get the I{authalic} earth radius (C{meter}), M{sqrt(c2x)}.

pygeodesy/fmath.py

@@ -25,7 +25,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '25.04.18'
+__version__ = '25.04.30'
 
 # sqrt(2) - 1 <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ~ 3_730_904_090_310_553 / 9_007_199_254_740_992
@@ -66,13 +66,27 @@ class Fdot(Fsum):
         self._facc_dot(n, a, b, **kwds)
 
 
+class Fdot_(Fdot):
+    '''Precision dot product.
+    '''
+    def __init__(self, *xys, **start_name_f2product_nonfinites_RESIDUAL):
+        '''New L{Fdot_} precision dot product M{sum(xys[i] * xys[i+1] for i in
+           range(0, len(xys), B{2}))}.
+
+           @arg xys: Pairwise values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}),
+                     all positional.
+
+           @see: Class L{Fdot<Fdot.__init__>} for further details.
+        '''
+        Fdot.__init__(self, xys[0::2], *xys[1::2], **start_name_f2product_nonfinites_RESIDUAL)
+
+
 class Fhorner(Fsum):
     '''Precision polynomial evaluation using the Horner form.
     '''
     def __init__(self, x, *cs, **incx_name_f2product_nonfinites_RESIDUAL):
-        '''New L{Fhorner} form evaluation of polynomial M{sum(cs[i] * x**i for
-           i=0..n)} with in- or decreasing exponent M{sum(... i=n..0)}, where C{n
-           = len(cs) - 1}.
+        '''New L{Fhorner} form evaluation of polynomial M{sum(cs[i] * x**i for i=0..n)}
+           with in- or decreasing exponent M{sum(... i=n..0)}, where C{n = len(cs) - 1}.
 
            @arg x: Polynomial argument (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @arg cs: Polynomial coeffients (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}),
@@ -454,7 +468,8 @@ def fdot_(*xys, **start_f2product_nonfinites):
 
        @return: Dot product (C{float}).
     '''
-    return fdot(xys[0::2], *xys[1::2], **start_f2product_nonfinites)
+    D = Fdot_(*xys, **_xkwds(start_f2product_nonfinites, nonfinites=True))
+    return float(D)
 
 
 def fdot3(xs, ys, zs, **start_f2product_nonfinites):
@@ -555,7 +570,7 @@ def fidw(xs, ds, beta=2):
 
 
 try:
-    from math import fma as _fma
+    from math import fma as _fma  # in .resections
 except  ImportError:  # PYCHOK DSPACE!
 
     def _fma(x, y, z):  # no need for accuracy

pygeodesy/fsums.py

@@ -64,7 +64,7 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '25.04.14'
+__version__ = '25.04.26'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -1485,7 +1485,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
     @deprecated_method
     def f2mul(self, *others, **raiser):
         '''DEPRECATED on 2024.09.13, use method L{f2mul_<Fsum.f2mul_>}.'''
-        return self._fset(self.f2mul_(others, **raiser))
+        return self._fset(self._f2mul(self.f2mul, others, **raiser))
 
     def f2mul_(self, *others, **f2product_nonfinites):  # in .fmath.f2mul
         '''Return C{B{self} * B{other} * B{other} ...} for all B{C{others}} using cascaded,