pygeodesy 24.5.24__py2.py3-none-any.whl → 24.6.1__py2.py3-none-any.whl

pygeodesy/formy.py

@@ -8,7 +8,7 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 # from pygeodesy.cartesianBase import CartesianBase  # _MODS
 from pygeodesy.constants import EPS, EPS0, EPS1, PI, PI2, PI3, PI_2, R_M, \
-                               _umod_PI2, float0_, isnon0, remainder, \
+                               _0_0s, float0_, isnon0, remainder, _umod_PI2, \
                                _0_0, _0_125, _0_25, _0_5, _1_0, _2_0, _4_0, \
                                _32_0, _90_0, _180_0, _360_0
 from pygeodesy.datums import Datum, Ellipsoid, _ellipsoidal_datum, \
@@ -16,18 +16,18 @@ from pygeodesy.datums import Datum, Ellipsoid, _ellipsoidal_datum, \
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
 from pygeodesy.errors import IntersectionError, LimitError, limiterrors, \
                             _TypeError, _ValueError, _xattr, _xError, \
-                            _xkwds, _xkwds_pop2
+                            _xcallable,_xkwds, _xkwds_pop2
 from pygeodesy.fmath import euclid, hypot, hypot2, sqrt0
 from pygeodesy.fsums import fsumf_,  Fmt, unstr
 # from pygeodesy.internals import _dunder_nameof  # from .named
-from pygeodesy.interns import _delta_, _distant_, _inside_, _not_, _SPACE_, _too_
+from pygeodesy.interns import _delta_, _distant_, _inside_, _SPACE_, _too_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name__, _name2__, _NamedTuple, _xnamed, \
                             _dunder_nameof
 from pygeodesy.namedTuples import Bearing2Tuple, Distance4Tuple, LatLon2Tuple, \
                                   Intersection3Tuple, PhiLam2Tuple, Vector3Tuple
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
-# from pygeodesy.triaxials import _hartzell2  # _MODS
+# from pygeodesy.triaxials import _hartzell3  # _MODS
 from pygeodesy.units import _isHeight, _isRadius, Bearing, Degrees_, Distance, \
                              Distance_, Height, Lam_, Lat, Lon, Meter_,  Phi_, \
                              Radians, Radians_, Radius, Radius_, Scalar, _100km
@@ -42,7 +42,7 @@ from contextlib import contextmanager
 from math import asin, atan, atan2, cos, degrees, fabs, radians, sin, sqrt  # pow
 
 __all__ = _ALL_LAZY.formy
-__version__ = '24.05.24'
+__version__ = '24.05.28'
 
 _RADIANS2 = (PI / _180_0)**2  # degrees- to radians-squared
 _ratio_   = 'ratio'
@@ -232,8 +232,8 @@ def cosineAndoyerLambert_(phi2, phi1, lam21, datum=_WGS84):
        @raise TypeError: Invalid B{C{datum}}.
 
        @see: Functions L{cosineAndoyerLambert}, L{cosineForsytheAndoyerLambert_},
-             L{cosineLaw_}, L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{haversine_}, L{thomas_} and L{vincentys_} and U{Geodesy-PHP
+             L{cosineLaw_}, L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{haversine_}, L{thomas_} and L{vincentys_} and U{Geodesy-PHP
              <https://GitHub.com/jtejido/geodesy-php/blob/master/src/Geodesy/Distance/
              AndoyerLambert.php>}.
     '''
@@ -298,8 +298,8 @@ def cosineForsytheAndoyerLambert_(phi2, phi1, lam21, datum=_WGS84):
        @raise TypeError: Invalid B{C{datum}}.
 
        @see: Functions L{cosineForsytheAndoyerLambert}, L{cosineAndoyerLambert_},
-             L{cosineLaw_}, L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{haversine_}, L{thomas_} and L{vincentys_} and U{Geodesy-PHP
+             L{cosineLaw_}, L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{haversine_}, L{thomas_} and L{vincentys_} and U{Geodesy-PHP
              <https://GitHub.com/jtejido/geodesy-php/blob/master/src/Geodesy/
              Distance/ForsytheCorrection.php>}.
     '''
@@ -366,9 +366,9 @@ def cosineLaw_(phi2, phi1, lam21):
        @return: Angular distance (C{radians}).
 
        @see: Functions L{cosineLaw}, L{cosineAndoyerLambert_},
-             L{cosineForsytheAndoyerLambert_}, L{equirectangular_},
-             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
-             L{haversine_}, L{thomas_} and L{vincentys_}.
+             L{cosineForsytheAndoyerLambert_},  L{euclidean_},
+             L{flatLocal_}/L{hubeny_}, L{flatPolar_}, L{haversine_},
+             L{thomas_} and L{vincentys_}.
 
        @note: See note at function L{vincentys_}.
     '''
@@ -430,35 +430,31 @@ def equirectangular(lat1, lon1, lat2, lon2, radius=R_M, **adjust_limit_wrap):
        @arg lon1: Start longitude (C{degrees}).
        @arg lat2: End latitude (C{degrees}).
        @arg lon2: End longitude (C{degrees}).
-       @kwarg radius: Mean earth radius (C{meter}), datum (L{Datum})
-                      or ellipsoid (L{Ellipsoid}, L{Ellipsoid2} or
-                      L{a_f2Tuple}).
-       @kwarg adjust_limit_wrap: Optional keyword arguments for
-                     function L{equirectangular_}.
+       @kwarg radius: Mean earth radius (C{meter}), datum (L{Datum}) or ellipsoid
+                      (L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}).
+       @kwarg adjust_limit_wrap: Optional keyword arguments for function L{equirectangular4}.
 
-       @return: Distance (C{meter}, same units as B{C{radius}} or
-                the ellipsoid or datum axes).
+       @return: Distance (C{meter}, same units as B{C{radius}} or the ellipsoid or datum axes).
 
        @raise TypeError: Invalid B{C{radius}}.
 
-       @see: Function L{equirectangular_} for more details, the
-             available B{C{options}}, errors, restrictions and other,
-             approximate or accurate distance functions.
+       @see: Function L{equirectangular4} for more details, the available B{C{options}},
+             errors, restrictions and other, approximate or accurate distance functions.
     '''
-    d = sqrt(equirectangular_(Lat(lat1=lat1), Lon(lon1=lon1),
+    d = sqrt(equirectangular4(Lat(lat1=lat1), Lon(lon1=lon1),
                               Lat(lat2=lat2), Lon(lon2=lon2),
                             **adjust_limit_wrap).distance2)  # PYCHOK 4 vs 2-3
     return degrees2m(d, radius=_mean_radius(radius, lat1, lat2))
 
 
 def _equirectangular(lat1, lon1, lat2, lon2, **adjust_limit_wrap):
-    '''(INTERNAL) Helper for the L{frechet._FrecherMeterRadians}
+    '''(INTERNAL) Helper for the L{frechet._FrechetMeterRadians}
        and L{hausdorff._HausdorffMeterRedians} classes.
     '''
-    return equirectangular_(lat1, lon1, lat2, lon2, **adjust_limit_wrap).distance2 * _RADIANS2
+    return equirectangular4(lat1, lon1, lat2, lon2, **adjust_limit_wrap).distance2 * _RADIANS2
 
 
-def equirectangular_(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False):
+def equirectangular4(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False):
     '''Compute the distance between two points using the U{Equirectangular Approximation
        / Projection<https://www.Movable-Type.co.UK/scripts/latlong.html#equirectangular>}.
 
@@ -469,15 +465,15 @@ def equirectangular_(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False):
        @arg lon1: Start longitude (C{degrees}).
        @arg lat2: End latitude (C{degrees}).
        @arg lon2: End longitude (C{degrees}).
-       @kwarg adjust: Adjust the wrapped, unrolled longitudinal delta
-                      by the cosine of the mean latitude (C{bool}).
-       @kwarg limit: Optional limit for lat- and longitudinal deltas
-                     (C{degrees}) or C{None} or C{0} for unlimited.
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{lat2}}
-                    and B{C{lon2}} (C{bool}).
+       @kwarg adjust: Adjust the wrapped, unrolled longitudinal delta by the cosine
+                      of the mean latitude (C{bool}).
+       @kwarg limit: Optional limit for lat- and longitudinal deltas (C{degrees}) or
+                     C{None} or C{0} for unlimited.
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{lat2}} and
+                    B{C{lon2}} (C{bool}).
 
-       @return: A L{Distance4Tuple}C{(distance2, delta_lat, delta_lon,
-                unroll_lon2)} in C{degrees squared}.
+       @return: A L{Distance4Tuple}C{(distance2, delta_lat, delta_lon, unroll_lon2)}
+                in C{degrees squared}.
 
        @raise LimitError: If the lat- and/or longitudinal delta exceeds the
                           B{C{-limit..limit}} range and L{pygeodesy.limiterrors}
@@ -498,7 +494,7 @@ def equirectangular_(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False):
         d = max(fabs(d_lat), fabs(d_lon))
         if d > limit:
             t = _SPACE_(_delta_, Fmt.PAREN_g(d), Fmt.exceeds_limit(limit))
-            s =  unstr(equirectangular_, lat1, lon1, lat2, lon2,
+            s =  unstr(equirectangular4, lat1, lon1, lat2, lon2,
                                          limit=limit, wrap=wrap)
             raise LimitError(s, txt=t)
 
@@ -551,9 +547,9 @@ def euclidean_(phi2, phi1, lam21, adjust=True):
        @return: Angular distance (C{radians}).
 
        @see: Functions L{euclid}, L{euclidean}, L{cosineAndoyerLambert_},
-             L{cosineForsytheAndoyerLambert_}, L{cosineLaw_}, L{equirectangular_},
-             L{flatLocal_}/L{hubeny_}, L{flatPolar_}, L{haversine_}, L{thomas_}
-             and L{vincentys_}.
+             L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
+             L{flatLocal_}/L{hubeny_}, L{flatPolar_}, L{haversine_},
+             L{thomas_} and L{vincentys_}.
     '''
     if adjust:
         lam21 *= _scale_rad(phi2, phi1)
@@ -866,8 +862,8 @@ def flatLocal_(phi2, phi1, lam21, datum=_WGS84, scaled=True):
 
        @see: Functions L{flatLocal} or L{hubeny}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_}, L{flatPolar_},
-             L{equirectangular_}, L{euclidean_}, L{haversine_}, L{thomas_}
-             and L{vincentys_} and U{local, flat earth approximation
+             L{euclidean_}, L{haversine_}, L{thomas_} and L{vincentys_} and
+             U{local, flat earth approximation
              <https://www.EdWilliams.org/avform.htm#flat>}.
     '''
     E = _ellipsoidal(datum, flatLocal_)
@@ -920,8 +916,8 @@ def flatPolar_(phi2, phi1, lam21):
 
        @see: Functions L{flatPolar}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
-             L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{haversine_}, L{thomas_} and L{vincentys_}.
+             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{haversine_},
+             L{thomas_} and L{vincentys_}.
     '''
     a = fabs(PI_2 - phi1)  # co-latitude
     b = fabs(PI_2 - phi2)  # co-latitude
@@ -964,9 +960,9 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
        @kwarg earth: The earth model (L{Datum}, L{Ellipsoid}, L{Ellipsoid2},
                      L{a_f2Tuple} or a C{scalar} earth radius in C{meter}).
        @kwarg name_LatLon_and_kwds: Optional, overriding C{B{name}="hartzell"}
-                   (C{str}), C{B{LatLon}=None} class to return the intersection
+                   (C{str}), class C{B{LatLon}=None} to return the intersection
                    plus additional C{LatLon} keyword arguments, include the
-                   B{C{datum}} if different from B{C{earth}}.
+                   B{C{datum}} if different and to convert from B{C{earth}}.
 
        @return: The intersection (L{Vector3d}, B{C{pov}}'s C{cartesian type} or the
                 given B{C{LatLon}} instance) with attribute C{heigth} set to the
@@ -981,15 +977,14 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
        @see: Class L{Los}, functions L{tyr3d} and L{hartzell4} and methods
              L{Ellipsoid.hartzell4} and any C{Cartesian.hartzell} and C{LatLon.hartzell}.
     '''
-    D = _spherical_datum(earth, name__=hartzell)
     n, LatLon_and_kwds = _name2__(name_LatLon_and_kwds, name__=hartzell)
     try:
+        D = _spherical_datum(earth, name__=hartzell)
         r, h, i = _MODS.triaxials._hartzell3(pov, los, D.ellipsoid._triaxial)
-        r = _xnamed(r, n)
 
         C = _MODS.cartesianBase.CartesianBase
         if LatLon_and_kwds:
-            c = C(r, datum=D, name=r.name)
+            c = C(r, datum=D)
             r = c.toLatLon(**_xkwds(LatLon_and_kwds, height=h))
         elif isinstance(r, C):
             r.height = h
@@ -998,7 +993,7 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
     except Exception as x:
         raise IntersectionError(pov=pov, los=los, earth=earth, cause=x,
                                                 **LatLon_and_kwds)
-    return r
+    return _xnamed(r, n) if n else r
 
 
 def haversine(lat1, lon1, lat2, lon2, radius=R_M, wrap=False):
@@ -1045,8 +1040,8 @@ def haversine_(phi2, phi1, lam21):
 
        @see: Functions L{haversine}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
-             L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{thomas_} and L{vincentys_}.
+             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{thomas_} and L{vincentys_}.
 
        @note: See note at function L{vincentys_}.
     '''
@@ -1111,8 +1106,8 @@ def heightOrthometric(h_ll, N):
 
 
 def horizon(height, radius=R_M, refraction=False):
-    '''Determine the distance to the horizon from a given altitude
-       above the (spherical) earth.
+    '''Determine the distance to the horizon from a given altitude above the
+       (spherical) earth.
 
        @arg height: Altitude (C{meter} or same units as B{C{radius}}).
        @kwarg radius: Optional mean earth radius (C{meter}).
@@ -1560,27 +1555,18 @@ def philam2n_xyz(phi, lam, **name):
     return _2n_xyz(name, *sincos2_(phi, lam))
 
 
-def _Propy(inst, nargs, **_prop_func):
+def _Propy(func, nargs, kwds):
     '''(INTERNAL) Helper for the C{frechet.[-]Frechet**} and
        C{hausdorff.[-]Hausdorff*} classes.
     '''
-    _prop, func = _prop_func.popitem()  # _xkwds_item2(_func_func)
-    if func is None:  # getter
-        try:
-            return inst.__dict__[_prop]
-        except KeyError:
-            inst._notOverloaded(**inst.kwds)
-    else:  # setter
-        try:
-            if not callable(func):
-                raise TypeError(_not_(callable.__name__))
-            args = (0,) * nargs
-            _ = func(*args, **inst.kwds)
-        except Exception as x:
-            t = unstr(func, **inst.kwds)
-            raise _TypeError(t, cause=x)
-        inst.__dict__[_prop] = func
-#       return func
+    try:
+        _xcallable(distance=func)
+        # assert _args_kwds_count2(func)[0] == nargs + int(ismethod(func))
+        _ = func(*_0_0s(nargs), **kwds)
+    except Exception as x:
+        t = unstr(func, **kwds)
+        raise _TypeError(t, cause=x)
+    return func
 
 
 def _radical2(d, r1, r2, **name):  # in .ellipsoidalBaseDI, .sphericalTrigonometry, .vector3d
@@ -1723,8 +1709,8 @@ def thomas_(phi2, phi1, lam21, datum=_WGS84):
 
        @see: Functions L{thomas}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
-             L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{haversine_} and L{vincentys_} and U{Geodesy-PHP
+             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{haversine_} and L{vincentys_} and U{Geodesy-PHP
              <https://GitHub.com/jtejido/geodesy-php/blob/master/src/Geodesy/
              Distance/ThomasFormula.php>}.
     '''
@@ -1806,8 +1792,8 @@ def vincentys_(phi2, phi1, lam21):
 
        @see: Functions L{vincentys}, L{cosineAndoyerLambert_},
              L{cosineForsytheAndoyerLambert_}, L{cosineLaw_},
-             L{equirectangular_}, L{euclidean_}, L{flatLocal_}/L{hubeny_},
-             L{flatPolar_}, L{haversine_} and L{thomas_}.
+             L{euclidean_}, L{flatLocal_}/L{hubeny_}, L{flatPolar_},
+             L{haversine_} and L{thomas_}.
 
        @note: Functions L{vincentys_}, L{haversine_} and L{cosineLaw_}
               produce equivalent results, but L{vincentys_} is suitable

pygeodesy/frechet.py

@@ -94,7 +94,7 @@ from pygeodesy.named import _name2__, _Named, _NamedTuple, _Pass
 # from pygeodesy.namedTuples import PhiLam2Tuple  # from .points
 from pygeodesy.points import _distanceTo, _fractional,  isscalar, \
                               PhiLam2Tuple, points2 as _points2, radians
-from pygeodesy.props import property_doc_, property_RO
+from pygeodesy.props import Property, property_doc_, property_RO
 from pygeodesy.units import FIx, Float, Number_, _xUnit, _xUnits
 from pygeodesy.unitsBase import _Str_degrees, _Str_meter, _Str_NN, \
                                 _Str_radians, _Str_radians2
@@ -103,7 +103,7 @@ from collections import defaultdict as _defaultdict
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.frechet
-__version__ = '24.05.24'
+__version__ = '24.05.26'
 
 
 def _fraction(fraction, n):
@@ -252,14 +252,14 @@ class Frechet(_Named):
 #       '''(INTERNAL) I{Must be overloaded}.'''
 #       self._notOverloaded(*args, **kwds)
 
-    @property
+    @Property
     def _func(self):
         '''(INTERNAL) I{Must be overloaded}.'''
-        return _formy._Propy(self, 0, _func=None)
+        self._notOverloaded(**self.kwds)
 
-    @_func.setter  # PYCHOK setter!
+    @_func.setter_  # PYCHOK setter_underscore!
     def _func(self, func):
-        _formy._Propy(self, 4, _func=func)
+        return _formy._Propy(func, 4, self.kwds)
 
     @property_RO
     def kwds(self):
@@ -382,14 +382,14 @@ class _FrechetMeterRadians(Frechet):
         '''
         return self._discrete(point2s, fraction, _formy._radistance(self))
 
-    @property
+    @Property
     def _func_(self):
         '''(INTERNAL) I{Must be overloaded}.'''
-        return _formy._Propy(self, 0, _func_=None)
+        self._notOverloaded(**self.kwds)
 
-    @_func_.setter  # PYCHOK setter!
+    @_func_.setter_  # PYCHOK setter_underscore!
     def _func_(self, func):
-        _formy._Propy(self, 3, _func_=func)
+        return _formy._Propy(func, 3, self.kwds)
 
 
 class FrechetCosineAndoyerLambert(_FrechetMeterRadians):
@@ -507,7 +507,7 @@ class FrechetEquirectangular(Frechet):
 
            @kwarg fraction_name__adjust_limit_wrap: Optional C{B{fraction}=None}
                                  and C{B{name}=NN} and keyword arguments for
-                                 function L{pygeodesy.equirectangular_} I{with
+                                 function L{pygeodesy.equirectangular} I{with
                                  default} C{B{limit}=0} for I{backward compatibility}.
 
            @see: L{Frechet.__init__} for details about B{C{point1s}}, B{C{fraction}},

pygeodesy/fsums.py

@@ -25,11 +25,11 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import isbool, iscomplex, isint, isscalar, \
                             _signOf, itemsorted, signOf, _xiterable, \
-                            _enquote
+                            _xiterablen,  _enquote
 from pygeodesy.constants import INT0, _isfinite, NEG0, _pos_self, \
                                _0_0, _1_0, _N_1_0,  Float, Int
 from pygeodesy.errors import _OverflowError, _TypeError, _UnexpectedError, \
-                             _ValueError, _xError, _xError2, _xkwds_get, \
+                             _ValueError, _xError, _xError2, _xkwds_get1, \
                              _xkwds_pop2
 # from pygeodesy.internals import _enquote  # from .basics
 from pygeodesy.interns import NN, _arg_, _COMMASPACE_, _DASH_, _DOT_, \
@@ -40,14 +40,14 @@ from pygeodesy.lazily import _ALL_LAZY, _getenv, _sys_version_info2
 from pygeodesy.named import _name__, _name2__, _Named, _NamedTuple, \
                             _NotImplemented
 from pygeodesy.props import _allPropertiesOf_n, deprecated_property_RO, \
-                             Property_RO, property_RO
+                             Property, Property_RO, property_RO
 from pygeodesy.streprs import Fmt, fstr, unstr
 # from pygeodesy.units import Float, Int  # from .constants
 
 from math import ceil as _ceil, fabs, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '24.05.24'
+__version__ = '24.05.29'
 
 _add_op_      = _PLUS_  # in .auxilats.auxAngle
 _eq_op_       = _EQUAL_ * 2  # _DEQUAL_
@@ -1105,6 +1105,26 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
 #               raise self._Error(op, other, _AssertionError, txt__=signOf)
         return DivMod2Tuple(q, self)  # q is C{int} in Python 3+, but C{float} in Python 2-
 
+    def _fhorner(self, x, cs, op):  # in .fmath
+        '''(INTERNAL) Add an L{Fhorner} evaluation of polynomial
+           M{sum(cs[i] * x**i for i=0..len(cs)-1)}.
+        '''
+        if _xiterablen(cs):
+            H = Fsum(name__=self._fhorner)
+            if _isFsumTuple(x):
+                _mul = H._mul_Fsum
+            else:
+                _mul = H._mul_scalar
+                x = _2float(x=x)
+            if len(cs) > 1 and x:
+                for c in reversed(cs):
+                    H._fset_ps(_mul(x, op))
+                    H._fadd(c, op, up=False)
+            else:  # x == 0
+                H = cs[0]
+            self._fadd(H, op)
+        return self
+
     def _finite(self, other, op=None):
         '''(INTERNAL) Return B{C{other}} if C{finite}.
         '''
@@ -1149,7 +1169,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         '''
         return Fsum2Tuple(*self._fint2, **name)
 
-    @Property_RO
+    @Property
     def _fint2(self):  # see ._fset
         '''(INTERNAL) Get 2-tuple (C{int}, I{integer} residual).
         '''
@@ -1159,6 +1179,13 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         r = self._ps_1sum(i) if r and n > 1 else float(s - i)
         return i, (r or INT0)  # Fsum2Tuple?
 
+    @_fint2.setter_  # PYCHOK setter_underscore!
+    def _fint2(self, s):
+        '''(INTERNAL) Replace the C{_fint2} value.
+        '''
+        i = int(s)
+        return i, ((s - i) or INT0)
+
     @deprecated_property_RO
     def float_int(self):  # PYCHOK no cover
         '''DEPRECATED, use method C{Fsum.int_float}.'''
@@ -1243,7 +1270,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             f = self._pow(other, other, op, **raiser_RESIDUAL)
         return self._fset(f)  # n=max(len(self), 1)
 
-    @Property_RO
+    @Property
     def _fprs(self):
         '''(INTERNAL) Get and cache this instance' precision
            running sum (C{float} or C{int}), ignoring C{residual}.
@@ -1254,7 +1281,13 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         s, _ = self._fprs2
         return s  # ._fprs2.fsum
 
-    @Property_RO
+    @_fprs.setter_  # PYCHOK setter_underscore!
+    def _fprs(self, s):
+        '''(INTERNAL) Replace the C{_fprs} value.
+        '''
+        return s
+
+    @Property
     def _fprs2(self):
         '''(INTERNAL) Get and cache this instance' precision
            running sum and residual (L{Fsum2Tuple}).
@@ -1278,6 +1311,12 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         # assert self._ps is ps
         return Fsum2Tuple(s, r)
 
+    @_fprs2.setter_  # PYCHOK setter_underscore!
+    def _fprs2(self, s_r):
+        '''(INTERNAL) Replace the C{_fprs2} value.
+        '''
+        return Fsum2Tuple(s_r)
+
     def fset_(self, *xs):
         '''Replace this instance' value with all positional items.
 
@@ -1310,27 +1349,22 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             s = float(self._finite(other, **op)) if op else other
             self._ps[:] = s,
             self._n     = n or 1
-            if up:
-                i = int(s)  # see ._fint2
-                t = i, ((s - i) or INT0)
-                # Property_ROs _fint2, _fprs and _fprs2 can't be a Property:
-                # Property's _fset zaps the value just set by the @setter
-                self.__dict__.update(_fint2=t, _fprs=s, _fprs2=Fsum2Tuple(s, INT0))
+            if up:  # Property _fint2, _fprs and _fprs2 all have
+                # @.setter_underscore and NOT @.setter because the
+                # latter's _fset zaps the value set by @.setter
+                self._fint2 = s
+                self._fprs  = s
+                self._fprs2 = s, INT0
+                # assert self._fprs is s
         else:  # PYCHOK no cover
-            op = _xkwds_get(op, op=_fset_op_)
+            op = _xkwds_get1(op, op=_fset_op_)
             raise self._Error(op, other, _TypeError)
         return self
 
-    def _fset_ps(self, other, n=0):  # in .fmath
+    def _fset_ps(self, other):  # in .fmath
         '''(INTERNAL) Set partials from a known C{scalar}, L{Fsum} or L{Fsum2Tuple}.
         '''
-        if _isFsumTuple(other):
-            self._ps[:] = other._ps
-            self._n     = n or other._n
-        else:  # assert isscalar(other)
-            self._ps[:] = other,
-            self._n     = n or 1
-        return self
+        return self._fset(other, up=False)
 
     def fsub(self, xs=()):
         '''Subtract an iterable's items from this instance.
@@ -1765,7 +1799,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         return self._pow_2_3(s, x, other, op, **raiser_RESIDUAL)
 
     def _ps_acc(self, ps, xs, up=True, **unused):
-        '''(INTERNAL) Accumulate C{xs} scalars into list C{ps}.
+        '''(INTERNAL) Accumulate C{xs} known scalars into list C{ps}.
         '''
         n   =  0
         _2s = _2sum
@@ -2192,7 +2226,7 @@ def fsum_(*xs, **floats):
 
        @see: Function L{fsum<fsums.fsum>} for further details.
     '''
-    return _fsum(xs if _xkwds_get(floats, floats=False) is True else
+    return _fsum(xs if _xkwds_get1(floats, floats=False) is True else
                 _2floats(xs, origin=1)) if xs else _0_0  # PYCHOK yield
 
 
@@ -2227,7 +2261,7 @@ def fsum1_(*xs, **floats):
 
        @see: Function L{fsum_<fsums.fsum_>} for further details.
     '''
-    return _fsum(_1primed(xs if _xkwds_get(floats, floats=False) is True else
+    return _fsum(_1primed(xs if _xkwds_get1(floats, floats=False) is True else
                          _2floats(xs, origin=1))) if xs else _0_0  # PYCHOK yield
 
 

pygeodesy/geodesicx/__init__.py

@@ -23,7 +23,7 @@ from pygeodesy.karney import Caps, GeodesicError
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 
 __all__ = _ALL_LAZY.geodesicx + _ALL_DOCS(Caps, GeodesicError)
-__version__ = '24.05.24'
+__version__ = '24.05.31'
 
 # **) MIT License
 #

pygeodesy/geodesicx/__main__.py

@@ -5,7 +5,7 @@ u'''Print L{geodesicx} version, etc. using C{python -m pygeodesy.geodesicx}.
 '''
 
 __all__ = ()
-__version__ = '24.05.13'
+__version__ = '24.05.31'
 
 
 def _C4stats(nC4=None):  # PYCHOK no cover
@@ -88,4 +88,4 @@ _main()
 # OTHER DEALINGS IN THE SOFTWARE.
 
 # % python3 -m pygeodesy.geodesicx
-# pygeodesy.geodesicx.version=21.05.30, .C4Order=None, .C4len=5425, .C4set=5107, .C4set100=94, .C4x=465 (Python 3.9.5, 64bit, geographiclib 1.52)
+# pygeodesy.geodesicx.version=24.05.31, .C4len=5425, .C4order=30, .C4set=5107, .C4set_len=94.1%, .C4x=465 (Python 3.12.3, 64bit, arm64, geographiclib 2.0)

pygeodesy/geodesicx/gx.py

@@ -62,7 +62,7 @@ from pygeodesy.utily import atan2d as _atan2d_reverse, _unrollon, _Wrap, wrap360
 from math import atan2, copysign, cos, degrees, fabs, radians, sqrt
 
 __all__ = ()
-__version__ = '24.05.20'
+__version__ = '24.05.31'
 
 _MAXIT1 = 20
 _MAXIT2 = 10 + _MAXIT1 + MANT_DIG  # MANT_DIG == C++ digits
@@ -150,9 +150,7 @@ class GeodesicExact(_GeodesicBase):
            @raise GeodesicError: Invalid B{C{C4order}}.
         '''
         if name_C4Order:
-            C4Order, name = _xkwds_pop2(name_C4Order, C4Order=C4order)
-            if C4Order:  # for backward compatibility
-                self.C4order = C4Order
+            C4order, name = _xkwds_pop2(name_C4Order, C4Order=C4order)
             if name:
                 self.name = name
         else:
@@ -318,7 +316,7 @@ class GeodesicExact(_GeodesicBase):
         def _C4(nC4):
             i, n, cs = 0, self.n, _C4coeffs(nC4)
             _p = _polynomial
-            for r in range(nC4 + 1, 1, -1):
+            for r in range(nC4 + 1, 1, -1):  # _reverange
                 for j in range(1, r):
                     j = j + i  # (j - i - 1) order of polynomial
                     yield _p(n, cs, i, j) / cs[j]

pygeodesy/geodsolve.py

@@ -26,7 +26,7 @@ from pygeodesy.solveBase import _SolveBase, _SolveLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.05.23'
+__version__ = '24.05.31'
 
 
 class GeodSolve12Tuple(_GTuple):
@@ -262,7 +262,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
         _xinstanceof(GeodesicSolve, geodesic=geodesic)
         if (caps & Caps.LINE_OFF):  # copy to avoid updates
             geodesic = geodesic.copy(deep=False, name=_UNDER_(NN, geodesic.name))  # NOT _under!
-        _SolveLineBase.__init__(self, geodesic, lat1, lon1, caps, name, azi1=azi1)
+        _SolveLineBase.__init__(self, geodesic, lat1, lon1, caps, azi1=azi1, **name)
         try:
             self.GeodSolve = geodesic.GeodSolve  # geodesic or copy of geodesic
         except GeodesicError: