pygeodesy 24.4.12__py2.py3-none-any.whl → 24.4.24__py2.py3-none-any.whl

pygeodesy/lazily.py

@@ -256,11 +256,11 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'crosserrors', 'exception_chaining', 'isError', 'limiterrors', 'rangerrors'),
                             etm=_i('Etm', 'ETMError', 'ExactTransverseMercator',
                                    'parseETM5', 'toEtm8'),
-                          fmath=_i('Fdot', 'Fhorner', 'Fhypot', 'Fpolynomial', 'Fpowers', 'Fn_rt', 'Fcbrt', 'Fsqrt',
+                          fmath=_i('Fdot', 'Fhorner', 'Fhypot', 'Fpolynomial', 'Fpowers', 'Fcbrt', 'Froot', 'Fsqrt',
                                    'bqrt', 'cbrt', 'cbrt2', 'euclid', 'euclid_',
                                    'facos1', 'fasin1', 'fatan', 'fatan1', 'fatan2', 'favg',
                                    'fdot', 'fdot3', 'fmean', 'fmean_', 'fhorner', 'fidw', 'fpolynomial',
-                                   'fpowers', 'fprod', 'frange', 'freduce', 'fremainder',
+                                   'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder',
                                    'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',
                                    'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'),
                           formy=_i('Radical2Tuple',
@@ -407,7 +407,7 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                            deprecated=_i('bases', 'datum', 'nvector',  # DEPRECATED modules and ...
                                          'rhumbaux', 'rhumbBase', 'rhumbsolve', 'rhumbx'),  # ... names
                      deprecated_bases=_i('LatLonHeightBase', 'points2'),
-                   deprecated_classes=_i('ClipCS3Tuple', 'EasNorExact4Tuple', 'EcefCartesian',
+                   deprecated_classes=_i('ClipCS3Tuple', 'EasNorExact4Tuple', 'EcefCartesian', 'Fn_rt',
                                          'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'Helmert7Tuple',
                                          'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple',
                                          'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple',
@@ -504,7 +504,7 @@ class _ALL_MODS(object):
 _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.04.07'
+__version__ = '24.04.22'
 
 
 def _ALL_OTHER(*objs):

pygeodesy/ltp.py

@@ -22,7 +22,7 @@ from pygeodesy.ecef import _EcefBase, EcefKarney, _llhn4, _xyzn4
 from pygeodesy.errors import _NotImplementedError, _TypesError, _ValueError, \
                              _xattr, _xkwds, _xkwds_get
 from pygeodesy.fmath import fabs, fdot, Fhorner
-from pygeodesy.fsums import _floor, Fsum, fsumf_, fsum1f_
+from pygeodesy.fsums import _floor, _Fsumf_, fsumf_, fsum1f_
 from pygeodesy.interns import NN, _0_, _COMMASPACE_, _DOT_, _ecef_, _height_, \
                              _invalid_, _lat0_, _lon0_, _ltp_, _M_, _name_, _too_
 # from pygeodesy.lazily import _ALL_LAZY  # from vector3d
@@ -42,7 +42,7 @@ from pygeodesy.vector3d import _ALL_LAZY, Vector3d
 # from math import fabs, floor as _floor  # from .fmath, .fsums
 
 __all__ = _ALL_LAZY.ltp
-__version__ = '24.04.07'
+__version__ = '24.04.14'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -964,15 +964,15 @@ class ChLVa(_ChLV, LocalCartesian):
         a, b, h      =  _ChLV._YXh_2abh3(Y, X, h_)
         ab_d, a2, b2 =   ChLV._ab_d, a**2, b**2
 
-        lat = Fsum(16.9023892, 3.238272 * b,
-                              -0.270978 * a2,
-                              -0.002528 * b2,
-                              -0.0447   * a2 * b,
-                              -0.014    * b2 * b).fover(ab_d)
-        lon = Fsum( 2.6779094, 4.728982 * a,
-                               0.791484 * a * b,
-                               0.1306   * a * b2,
-                              -0.0436   * a * a2).fover(ab_d)
+        lat = _Fsumf_(16.9023892, 3.238272 * b,
+                                 -0.270978 * a2,
+                                 -0.002528 * b2,
+                                 -0.0447   * a2 * b,
+                                 -0.014    * b2 * b).fover(ab_d)
+        lon = _Fsumf_( 2.6779094, 4.728982 * a,
+                                  0.791484 * a * b,
+                                  0.1306   * a * b2,
+                                 -0.0436   * a * a2).fover(ab_d)
         return self._ChLV9Tuple(False, M, name, Y, X, h_, lat, lon, h)
 
 

pygeodesy/osgr.py

@@ -34,8 +34,8 @@ from pygeodesy.datums import Datums, _ellipsoidal_datum, _WGS84
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB
 from pygeodesy.errors import _parseX, _TypeError, _ValueError, \
                              _xkwds, _xkwds_get
-from pygeodesy.fmath import Fdot, fpowers, Fsum
-# from pygeodesy.fsums import Fsum  # from .fmath
+from pygeodesy.fmath import Fdot, fpowers
+from pygeodesy.fsums import _Fsumf_
 from pygeodesy.interns import MISSING, NN, _A_, _COLON_, _COMMA_, \
                              _COMMASPACE_, _DOT_, _ellipsoidal_, \
                              _latlon_, _not_, _SPACE_
@@ -121,10 +121,10 @@ class _NG(object):
     @Property_RO
     def Mabcd(self):  # meridional coefficients (a, b, c, d)
         n, n2, n3 = fpowers(self.ellipsoid.n, 3)
-        M = (Fsum(4,  4 * n,  5 * n2,  5 * n3) / 4,
-             Fsum(   24 * n, 24 * n2, 21 * n3) / 8,
-             Fsum(           15 * n2, 15 * n3) / 8,
-                                     (35 * n3 / 24))
+        M = (_Fsumf_(4,  4 * n,  5 * n2,  5 * n3) / 4,
+             _Fsumf_(   24 * n, 24 * n2, 21 * n3) / 8,
+             _Fsumf_(           15 * n2, 15 * n3) / 8,
+                                        (35 * n3 / 24))
         return M
 
     def Mabcd0(self, a):  # meridional arc, scaled
@@ -327,10 +327,10 @@ class Osgr(_NamedBase):
             e0 =     self.easting  - NG.eas0
             n0 = m = self.northing - NG.nor0
 
-            _M = NG.Mabcd0
-            a0 = NG.a0
-            a  = NG.phi0
-            _A = Fsum(a).fsum_
+            _M =  NG.Mabcd0
+            a0 =  NG.a0
+            a  =  NG.phi0
+            _A = _Fsumf_(a).fsum_
             for self._iteration in range(1, _TRIPS):
                 a = _A(m / a0)
                 m = n0 - _M(a)  # meridional arc
@@ -354,14 +354,14 @@ class Osgr(_NamedBase):
             d2  = d**2
 
             a = (d2 * ta * (-1 +  # Horner-like
-                 d2 / 12 * (Fsum( 5,  3 * ta2, -9 * ta2 * n2, n2) -
-                 d2 / 30 *  Fsum(61, 90 * ta2, 45 * ta4)))).fsum_(a)
+                 d2 / 12 * (_Fsumf_( 5,  3 * ta2, -9 * ta2 * n2, n2) -
+                 d2 / 30 *  _Fsumf_(61, 90 * ta2, 45 * ta4)))).fsum_(a)
 
-            b = (d  / ca * (1 -  # Horner-like
-                 d2 /  6 * (Fsum(v_r,  2 * ta2) -
-                 d2 / 20 * (Fsum( 5,  28 * ta2,   24 * ta4) +
-                 d2 / 42 *  Fsum(61, 662 * ta2, 1320 * ta4,
-                                     720 * ta2 * ta4))))).fsum_(NG.lam0)
+            b = (d  / ca * ( 1 -  # Horner-like
+                 d2 /  6 * (_Fsumf_(v_r,  2 * ta2) -
+                 d2 / 20 * (_Fsumf_( 5,  28 * ta2,   24 * ta4) +
+                 d2 / 42 *  _Fsumf_(61, 662 * ta2, 1320 * ta4,
+                                        720 * ta2 * ta4))))).fsum_(NG.lam0)
 
             r = _LLEB(degrees90(a), degrees180(b), datum=self.datum, name=self.name)
             r._iteration = self._iteration  # only ellipsoidal LatLon
@@ -652,14 +652,14 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
         ta2 = -(ta**2)
         ta4 =   ta2**2
 
-        e = (d  *  v * (1 +  # Horner-like
-             d2 /  6 * (Fsum(v_r, ta2) +
-             d2 / 20 *  Fsum(5,  18 * ta2, ta4, 14 * n2,
-                            58 * n2 * ta2)))).fsum_(NG.eas0)
+        e = (d  *  v * ( 1 +  # Horner-like
+             d2 /  6 * (_Fsumf_(v_r, ta2) +
+             d2 / 20 *  _Fsumf_(5,  18 * ta2, ta4, 14 * n2,
+                               58 * n2 * ta2)))).fsum_(NG.eas0)
 
-        n = (d  *  t * (1 +  # Horner-like
-             d2 / 12 * (Fsum( 5, ta2,  9 * n2) +
-             d2 / 30 *  Fsum(61, ta4, 58 * ta2)))).fsum_(m0, NG.nor0)
+        n = (d  *  t * ( 1 +  # Horner-like
+             d2 / 12 * (_Fsumf_( 5, ta2,  9 * n2) +
+             d2 / 30 *  _Fsumf_(61, ta4, 58 * ta2)))).fsum_(m0, NG.nor0)
 
     p, kwds = _prec_kwds2(**prec_Osgr_kwds)
     if p is not MISSING:

pygeodesy/resections.py

@@ -20,7 +20,7 @@ from pygeodesy.constants import EPS, EPS0, EPS02, INT0, PI, PI2, PI_2, PI_4, \
 from pygeodesy.errors import _and, _or, TriangleError, _ValueError, _xcallable, \
                              _xkwds, _xkwds_pop2
 from pygeodesy.fmath import favg, Fdot, fidw, fmean, hypot, hypot2_
-from pygeodesy.fsums import Fsum, fsumf_, fsum1, fsum1f_
+from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1, fsum1f_
 from pygeodesy.interns import _a_, _A_, _area_, _b_, _B_, _c_, _C_, _coincident_, \
                               _colinear_, _d_, _eps_, _invalid_, _negative_, _not_, \
                               _rIn_, _SPACE_
@@ -34,7 +34,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d
 from math import cos, atan2, degrees, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.resections
-__version__ = '24.04.04'
+__version__ = '24.04.14'
 
 _concyclic_ = 'concyclic'
 _PA_        = 'PA'
@@ -57,14 +57,6 @@ class Collins5Tuple(_NamedTuple):
     _Units_ = (_Pass,    _Pass,     Distance, Distance, Distance)
 
 
-def _F1(*xs):  # class
-    '''(INTERNAL) An L{Fsum}, 1-primed.
-    '''
-    F  =  Fsum(_1_0, *xs)
-    F += _N_1_0
-    return F
-
-
 class ResectionError(_ValueError):
     '''Error raised for issues in L{pygeodesy.resections}.
     '''
@@ -376,8 +368,8 @@ def _pierlot3(B1, B2, B3, a12, a23, useZ, cot):
     cot31 = cot(fsum1f_(c12 * s23,  s12 * c23),  # s31
                 fsum1f_(s12 * s23, -c12 * c23))  # c31
 
-    K = _F1(x3_ * x1_,  cot31 * (y3_ * x1_),
-            y3_ * y1_, -cot31 * (x3_ * y1_))
+    K = _Fsumf_(x3_ * x1_,  cot31 * (y3_ * x1_),
+                y3_ * y1_, -cot31 * (x3_ * y1_))
     if K:
         cot12 = cot(s12, c12)
         cot23 = cot(s23, c23)
@@ -392,16 +384,16 @@ def _pierlot3(B1, B2, B3, a12, a23, useZ, cot):
         # y31 = y3_ + y1_ - cot31 * (x3_ - x1_)
 
         # x12 - x23 = x1_ + cot12 * y1_ - x3_ + cot23 * y3_
-        X12_23 = _F1(x1_,  cot12 * y1_, -x3_,  cot23 * y3_)
+        X12_23 = _Fsumf_(x1_,  cot12 * y1_, -x3_,  cot23 * y3_)
         # y12 - y23 = y1_ - cot12 * x1_ - y3_ - cot23 * x3_
-        Y12_23 = _F1(y1_, -cot12 * x1_, -y3_, -cot23 * x3_)
+        Y12_23 = _Fsumf_(y1_, -cot12 * x1_, -y3_, -cot23 * x3_)
 
         # x31 - x23 = x3_ + x1_ + cot31 * (y3_ - y1_) - x3_ + cot23 * y3_
         #           = x1_ + cot31 * y3_ - cot31 * y1_ + cot23 * y3_
-        X31_23 = _F1(x1_, -cot31 * y1_,  cot31 * y3_,  cot23 * y3_)
+        X31_23 = _Fsumf_(x1_, -cot31 * y1_,  cot31 * y3_,  cot23 * y3_)
         # y31 - y23 = y3_ + y1_ - cot31 * (x3_ - x1_) - y3_ - cot23 * x3_
         #           = y1_ - cot31 * x3_ + cot31 * x1_ - cot23 * x3_
-        Y31_23 = _F1(y1_,  cot31 * x1_, -cot31 * x3_, -cot23 * x3_)
+        Y31_23 = _Fsumf_(y1_,  cot31 * x1_, -cot31 * x3_, -cot23 * x3_)
 
         # d = (x12 - x23) * (y23 - y31) + (x31 - x23) * (y12 - y23)
         #   = (x31 - x23) * (y12 - y23) - (x12 - x23) * (y31 - y23)
@@ -495,7 +487,7 @@ def _pierlotx3(a_z_Bs, useZ, cot, Cs):
     x1_, y1_, _ = B1.minus(B3).xyz
     x2_, y2_, _ = B2.minus(B3).xyz
 
-    K = _F1(y1_ * x2_, -x1_ * y2_)
+    K = _Fsumf_(y1_ * x2_, -x1_ * y2_)
     if K:
         cot23 = cot(*sincos2d(a23))
 
@@ -506,15 +498,15 @@ def _pierlotx3(a_z_Bs, useZ, cot, Cs):
         # y31 = y1_ - cot23 * x1_
 
         # x31 - x23 = x1_ + cot23 * y1_ - x2_ - cot23 * y2_
-        X31_23 = _F1(x1_,  cot23 * y1_, -x2_, -cot23 * y2_)
+        X31_23 = _Fsumf_(x1_,  cot23 * y1_, -x2_, -cot23 * y2_)
         # y31 - y23 = y1_ - cot23 * x1_ - y2_ + cot23 * x2_
-        Y31_23 = _F1(y1_, -cot23 * x1_, -y2_,  cot23 * x2_)
+        Y31_23 = _Fsumf_(y1_, -cot23 * x1_, -y2_,  cot23 * x2_)
 
         # d = (x31 - x23) * (x2_ - x1_) + (y31 - y23) * (y2_ - y1_)
         # x = (D * B3.x - K * Y31_23).fover(d)
         # y = (D * B3.y + K * X31_23).fover(d)
-        x, y = _pierlotxy2(B3, K, Y31_23, X31_23, (X31_23 * _F1(x2_, -x1_) +
-                                                   Y31_23 * _F1(y2_, -y1_)))
+        x, y = _pierlotxy2(B3, K, Y31_23, X31_23, (X31_23 * _Fsumf_(x2_, -x1_) +
+                                                   Y31_23 * _Fsumf_(y2_, -y1_)))
     else:
         x, y, _ = B3.xyz
     return x, y, _zidw(x, y, useZ, B1, B2, B3)
@@ -974,7 +966,7 @@ def wildberger3(a, b, c, alpha, beta, R3=min):
     def _vpa(r3, q2, q3, s2, s3):
         r1 = s2 * q3 / s3
         r  = r1 * r3 * _4_0
-        n  = (r - _F1(r1, r3, -q2)**2).fover(s3)
+        n  = (r - _Fsumf_(r1, r3, -q2)**2).fover(s3)
         if n < 0 or r < EPS0:
             raise ValueError(_coincident_)
         return sqrt((n / r) * q3) if n else _0_0
@@ -994,11 +986,11 @@ def wildberger3(a, b, c, alpha, beta, R3=min):
             raise ValueError(_or(_coincident_, _colinear_))
 
         q4 =  hypot2_(*q) * _2_0  # a**4 + ...
-        Qs = _F1(*q)   # == hypot2_(a, b, c)
+        Qs = _Fsumf_(*q)   # == hypot2_(a, b, c)
         d0 = (Qs**2 - q4).fmul(s1 * s2).fover(s3)
         if d0 < 0:
             raise ValueError(_negative_)
-        s += _F1(*s),  # == fsum1(s),
+        s += _Fsumf_(*s),  # == fsum1(s),
         C0 =  Fdot(s, q1, q2, q3, -Qs * _0_5)
         r3 =  C0.fover(-s3)  # C0 /= -s3
         if d0 > EPS02:  # > c0

pygeodesy/triaxials.py

@@ -40,7 +40,7 @@ from pygeodesy.datums import Datum, _spherical_datum, _WGS84,  Ellipsoid, _EWGS8
 # from pygeodesy.elliptic import Elliptic  # _MODS
 # from pygeodesy.errors import _ValueError  # from .basics
 from pygeodesy.fmath import Fdot, fdot, fmean_, hypot, hypot_, norm2, sqrt0
-from pygeodesy.fsums import Fsum, fsumf_, fsum1f_
+from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1f_
 from pygeodesy.interns import NN, _a_, _b_, _beta_, _c_, _distant_, _finite_, \
                              _height_, _inside_, _near_, _negative_, _not_, \
                              _NOTEQUAL_, _null_, _opposite_, _outside_, _SPACE_, \
@@ -59,7 +59,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d,  _ALL_LAZY, _MODS
 from math import atan2, fabs, sqrt
 
 __all__ = _ALL_LAZY.triaxials
-__version__ = '24.01.21'
+__version__ = '24.04.14'
 
 _not_ordered_ = _not_('ordered')
 _omega_       = 'omega'
@@ -805,8 +805,8 @@ class Triaxial(Triaxial_):
         c2_a2   = -self._1e2ac  # == -(c/a)**2
         a2c2_a2 =  self.  e2ac  # (a**2 - c**2) / a**2 == 1 - (c/a)**2
 
-        x2 = Fsum(_1_0, -b2_a2 * sa**2, c2_a2 * ca**2).fover(a2c2_a2)
-        z2 = Fsum(c2_a2,         sb**2, b2_a2 * cb**2).fover(a2c2_a2)
+        x2 = _Fsumf_(_1_0, -b2_a2 * sa**2, c2_a2 * ca**2).fover(a2c2_a2)
+        z2 = _Fsumf_(c2_a2,         sb**2, b2_a2 * cb**2).fover(a2c2_a2)
 
         x, y, z = self._abc3
         x *= cb * sqrt0(x2, Error=TriaxialError)

pygeodesy/vector2d.py

@@ -12,7 +12,7 @@ from pygeodesy.constants import EPS, EPS0, EPS02, EPS4, INF, INT0, \
 from pygeodesy.errors import _and, _AssertionError, IntersectionError, NumPyError, \
                               PointsError, TriangleError, _xError, _xkwds
 from pygeodesy.fmath import fabs, fdot, hypot, hypot2_, sqrt
-from pygeodesy.fsums import Fsum, fsumf_, fsum1f_
+from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1f_
 from pygeodesy.interns import NN, _a_, _and_, _b_, _c_, _center_, _coincident_, \
                              _colinear_, _COMMASPACE_, _concentric_, _few_, \
                              _intersection_, _invalid_, _near_, _no_, _of_, \
@@ -30,7 +30,7 @@ from contextlib import contextmanager
 # from math import fabs, sqrt  # from .fmath
 
 __all__ = _ALL_LAZY.vector2d
-__version__ = '23.11.17'
+__version__ = '24.04.18'
 
 _cA_        = 'cA'
 _cB_        = 'cB'
@@ -354,10 +354,11 @@ def _meeus4(A, point2, point3, circum=False, useZ=True, clas=None, **clas_kwds):
         a, c, A, C = c, a, C, A
 
     if a > EPS02 and (circum or a < (b + c)):  # circumradius
-        b = sqrt(b / a)
-        c = sqrt(c / a)
-        R = Fsum(_1_0, b, c) * Fsum(_1_0, b, -c) * Fsum(_1_0, -b, c) * Fsum(_N_1_0, b, c)
-        r = R.fover(a)
+        b =  sqrt(b / a)
+        c =  sqrt(c / a)
+        R = _Fsumf_(_1_0,  b, c) * _Fsumf_(_1_0,   b, -c) * \
+            _Fsumf_(_1_0, -b, c) * _Fsumf_(_N_1_0, b,  c)
+        r =  R.fover(a)
         if r < EPS02:
             raise IntersectionError(_coincident_ if b < EPS0 or c < EPS0 else (
                                     _colinear_ if _iscolinearWith(A, B, C) else _invalid_))
@@ -503,8 +504,8 @@ def _radii11ABC(point1, point2, point3, useZ=True):
     b = C.minus(A).length
     c = A.minus(B).length
 
-    S = Fsum(a, b, c) * _0_5
-    s = float(S)  # semi-perimeter
+    S = _Fsumf_(a, b, c) * _0_5
+    s =  float(S)  # semi-perimeter
     if s > EPS0:
         rs = float(S - a), float(S - b), float(S - c)
         r3, r2, r1 = sorted(rs)  # r3 <= r2 <= r1