pygeodesy 24.4.2__py2.py3-none-any.whl → 24.4.4__py2.py3-none-any.whl

{PyGeodesy-24.4.2.dist-info → PyGeodesy-24.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyGeodesy
-Version: 24.4.2
+Version: 24.4.4
 Summary: Pure Python geodesy tools
 Home-page: https://GitHub.com/mrJean1/PyGeodesy
 Author: Jean M. Brouwers
@@ -118,7 +118,7 @@ The tests ran with Python 3.12.2 (with geographiclib_ 2.0), 3.11.5 (with geograp
 1.24.2 and scipy_ 1.10.1), Python 3.10.8 (with geographiclib_ 2.0, numpy_ 1.23.3, scipy_ 1.9.1,
 GeoConvert_ 2.2, GeodSolve_ 2.2 and RhumbSolve_ 2.2), Python 3.9.6 and Python 2.7.18 (with geographiclib_
 1.50, numpy_ 1.16.6, scipy_ 1.2.2, GeoConvert_ 2.2, GeodSolve_ 2.2 and RhumbSolve_ 2.2), all on macOS
-14.3.1 Sonoma and in 64-bit only.
+14.4.1 Sonoma and in 64-bit only.
 
 All tests ran with and without ``lazy import`` for Python 3 and with command line option ``-W default``
 and env variable ``PYGEODESY_WARNINGS=on`` for all Python versions.  The results of those tests are
@@ -143,7 +143,7 @@ numpy_ 1.16.3, 1.16.4, 1.16.6, 1.19.0, 1.19.4, 1.19.5 or 1.22.4 and scipy_ 1.2.1
 on `Ubuntu 16.04`_, with Python 3.10.0-1, 3.9.0-5, 3.8.0-6, 3.7.2-6, 3.7.0, 3.6.2-5, 3.5.3, 2.7.13-17,
 2.7.10 and 2.6.9 (and numpy_ 1.19.0, 1.16.5, 1.16.2, 1.15.2, 1.14.0, 1.13.1, 1.8.0rc1 or 1.6.2 and scipy_
 1.5.0), PyPy_ 7.3.0 (Python 2.7.13 and 3.6.9), PyPy_ 6.0.0 (Python 2.7.13 and 3.5.3) and `Intel-Python`_
-3.5.3 (and numpy_ 1.11.3) on macOS 14.0-2.1 Sonoma, 13.0-5.2 Ventura, 12.1-6 Monterey, 11.0-5.2-6.1 Big
+3.5.3 (and numpy_ 1.11.3) on macOS 14.0-3.1 Sonoma, 13.0-5.2 Ventura, 12.1-6 Monterey, 11.0-5.2-6.1 Big
 Sur (aka 10.16), 10.15.3, 10.15.5-7 Catalina, 10.14 Mojave, 10.13.6 High Sierra and 10.12 Sierra, MacOS X
 10.11 El Capitan and/or MacOS X 10.10 Yosemite, with Pythonista_ 3.2 (with geographiclib 1.50 or 1.49 and
 numpy 1.8.0) on iOS 14.4.2, 11.4.1, 12.0-3 on iPad4, iPhone6, iPhone10 and/or iPhone12, with Pythonista_
@@ -154,11 +154,11 @@ Notes
 =====
 
 All Python source code has been statically checked_ with PyChecker_, PyFlakes_, PyCodeStyle_ (formerly Pep8)
-and McCabe_ using Python 2.7.18 and with Flake8_ using Python 3.11.5, both in 64-bit on macOS 14.3.1 Sonoma.
+and McCabe_ using Python 2.7.18 and with Flake8_ using Python 3.11.5, both in 64-bit on macOS 14.4.1 Sonoma.
 
 For a summary of all *Karney*-based functionality in ``pygeodesy``, see module karney_.
 
-*Last updated: April 02, 2024.*
+*Last updated: April 04, 2024.*
 
 License
 =======

{PyGeodesy-24.4.2.dist-info → PyGeodesy-24.4.4.dist-info}/RECORD

@@ -1,13 +1,13 @@
 pygeodesy/LICENSE,sha256=YfgAiyxOwY6P9Kkb1_5XN81nueTLrpb3Ffkv3EuPgFU,1144
-pygeodesy/__init__.py,sha256=_3ZB1L61RzVekqZjnjG1Q-nWx4O6g6fbCUm9ygiBoQU,40824
+pygeodesy/__init__.py,sha256=3Zu_6m7CtOUuHraPspTn-gTN03b8oW_SyNpfhSibkTI,40824
 pygeodesy/__main__.py,sha256=qMFG3caY8ZXWu6uGiemzyT4OqTFZnsFtlxcGCAgkVJw,4637
 pygeodesy/albers.py,sha256=UpWNezHXFuA_kT5PhH_2V_gGFJjcmVLLogl5ScJloPU,31098
 pygeodesy/azimuthal.py,sha256=e796vtU5ol5ZG2yBX3E5YBXsONJuCrhyEX60YzGzFi0,50115
-pygeodesy/basics.py,sha256=tkHRN1-4wcZyniACBp9K5RJSrrFVIEmaVt9a0celNGk,27687
+pygeodesy/basics.py,sha256=_BMYLzGKA6OIS3qv25HfHy7MIh0kAbmkzyScb59clUs,28160
 pygeodesy/booleans.py,sha256=HZbwoL-S7Ww9d4C2D1BVqXfmcuqqVpEVSU9_S0uyUyo,74204
 pygeodesy/cartesianBase.py,sha256=I3q29mRdBB3NCDmPoJsJ0QOFfLzkdMWc8X9zG4IwJyA,47264
 pygeodesy/clipy.py,sha256=VU3ynQ1IZ0v5hJlicqD48oW0imRgiL5_ZzRPrIjpfPw,27683
-pygeodesy/constants.py,sha256=0ooop-YabUzSvO1Z3Q3J6P--LT-ViR83om4aj6PlqOg,19144
+pygeodesy/constants.py,sha256=ypxYsWB6tNAVgrD9QVpukJAPscaLgHtPLqPuot1gUfU,19174
 pygeodesy/css.py,sha256=sKXsahUiyruDcUk-tGjA6mxq-xzwBoBKxKo9_b2uBmY,25394
 pygeodesy/datums.py,sha256=gJZPgV4bELZvZ8Sj2zE3MBysVtsLxqsN8zm0xjOKvpo,33851
 pygeodesy/dms.py,sha256=op3MU-59CoJQRdybnu21aVM9wtocd_-XFNAZFqmozSo,44439
@@ -25,11 +25,11 @@ pygeodesy/elliptic.py,sha256=n2R-3H1ruMnwBewEtn75ahjpgeEU93irzcvFxarCyPs,42393
 pygeodesy/epsg.py,sha256=ldHoLWqJWR4FUiBVnDTtrI_e7TNjjtr9OkxDlri1g5E,8165
 pygeodesy/errors.py,sha256=fRGrdnb81Y9KB4Y1ua1nvB9zuuiv8IL6c6YN_cb3kBo,27280
 pygeodesy/etm.py,sha256=ADIMY8zxVu3cAiP9rUGj3Mq3LyO2C5w3ejdW2YY1eJ8,44583
-pygeodesy/fmath.py,sha256=z0YBdZW92NaLM0VEyx6ItTIjuf3I6PhRce27OUl_RnM,30360
+pygeodesy/fmath.py,sha256=cmObX2axb8BfPyhaSDGFFVRs63kBP4ZWhWzGzPhl6OQ,30286
 pygeodesy/formy.py,sha256=Rces4Q5ecED0WVfuI9mQzeyHE54LDowYfI6faBHpyeA,74536
 pygeodesy/frechet.py,sha256=1tiLc6WZou8YVbizB0QisVhYH-VOP03pMZQ5GOAb9Dc,33527
 pygeodesy/fstats.py,sha256=X79Qd8pL4R-kUIYN0CZDuA7L1UArtBFvWqaFoHASNqs,25605
-pygeodesy/fsums.py,sha256=3Fdnk0ZJmg05qoJmUSLH8ra4mQQKuDFDTdD5L4jio5U,67166
+pygeodesy/fsums.py,sha256=a2rhCX73eZbyiKYvk06T4q9l1QkGxYQ50T7N21oGRl8,68591
 pygeodesy/gars.py,sha256=fCiWBJ4kOJxPfNOxadX-OzBGDXj7C9g02NuGHiZa_88,11342
 pygeodesy/geodesicw.py,sha256=Rw1pmT8UabWsBKfecsd4VR5Ks3uMrhH8sufydJS_MMs,26901
 pygeodesy/geodsolve.py,sha256=J75l_bbPPsPr4NZXm1hCASl9TrXAS5DSeufXYkz2Qzs,21863
@@ -53,7 +53,7 @@ pygeodesy/nvectorBase.py,sha256=vpuGECs038I-8z_MDFJ9gZMY_6Een-EG2Y_llRLpl-o,2879
 pygeodesy/osgr.py,sha256=5JB6b_nvyZ6rFMlC7ZB45mvYtjc_aiLb4DPdeaui-KY,30995
 pygeodesy/points.py,sha256=8LiAH1dMiNN6mLmBZAisI0VsccD9PSy97XhDtJUfBuw,64441
 pygeodesy/props.py,sha256=ZnXRuSOkfkeJY3Of-iT06FNWZkTYgLZQBPBNF6aS0jE,21421
-pygeodesy/resections.py,sha256=ILXfcWkHH-WP2eczhYw6p5HANZXH_sttfhdJBM22l-k,43586
+pygeodesy/resections.py,sha256=WGGsWgN9LCcJ9YCo-lbgtuA9VqEWnYvoe3OFOJ4nYFk,43619
 pygeodesy/simplify.py,sha256=FT3AzXiFjFfvwJ-X2q8iA9cQOUVdBT1vD_BIskM3gK8,25223
 pygeodesy/solveBase.py,sha256=cBe3QQWEaJlPWUlXoiYo1eFMh4z6GDZbQyt8ZiwMfos,16687
 pygeodesy/sphericalBase.py,sha256=sH2WwmY_RL0STyr1OhtCDKvGhO0Ks7o3V-MHLddpiHQ,31944
@@ -65,7 +65,7 @@ pygeodesy/triaxials.py,sha256=Yet0J9Fr4FbTEIL9_p3ziollRR3PzUN2-qt7Z9ZSODU,61537
 pygeodesy/units.py,sha256=ofFTYc7mF9wOpfvpYHN83dGszMM18rTdsxfEXVzaIko,38705
 pygeodesy/unitsBase.py,sha256=xRZlNlO7S47Mwy0FGBg_cefvB4fEtWFM5dAE-Nlw-NE,13111
 pygeodesy/ups.py,sha256=07AG-Rb1D4EvmN3g-xk3ZxKzyaNYvOzztcyYbx7t8jc,23229
-pygeodesy/utily.py,sha256=O9y9G02kRKtcvTyGJqxWaYDA10rv3mPhTub4VTQmrQI,36105
+pygeodesy/utily.py,sha256=jP82RmCPCVghxTQv4ZRuIS89afmsD-roz2iafHfyHXA,36128
 pygeodesy/utm.py,sha256=0qF5Kjw8Wf9zxGWOaCF-LSweibat-EkHvvmy7dFO_KE,30981
 pygeodesy/utmups.py,sha256=u2hlWSnmZKwR-ApgKw16R9p75sW_yaqQAmbcBUE8Zfg,13007
 pygeodesy/utmupsBase.py,sha256=5mKmo2cGSCJM8Q5oRQ7tmGJgRTdIgRVncCwG_BqB030,18816
@@ -109,7 +109,7 @@ pygeodesy/rhumb/aux_.py,sha256=W4HkgoHAQz_aWaysfsmOA5010nCGvBfUs2Q-bymnHYU,16660
 pygeodesy/rhumb/bases.py,sha256=ZZ4Ba0Cl45tQdfEquyQPSQdH2vXgemF3tCw6UuzHphs,53893
 pygeodesy/rhumb/ekx.py,sha256=lF3tZ-ZY9fPJV8y1kgHW-7EOZCyb3gJr-kR-jj5Fbf8,23871
 pygeodesy/rhumb/solve.py,sha256=NZfwx7xv5UriQs7A0c7ZhoxxVUeAT15UwXK_jtwEXQw,27802
-PyGeodesy-24.4.2.dist-info/METADATA,sha256=hh9f4N7AItjpHOMK6dzULDBjunNb4dIoN4WIiVUxsDQ,19365
-PyGeodesy-24.4.2.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
-PyGeodesy-24.4.2.dist-info/top_level.txt,sha256=cEQPatCXzKZqrivpULC5V5fuy9_V_bAwaP_gUGid7pQ,10
-PyGeodesy-24.4.2.dist-info/RECORD,,
+PyGeodesy-24.4.4.dist-info/METADATA,sha256=pWgDCMFWPNFawFtWPa1q4SpV_5XDSJx4r5MvNyFpXjE,19365
+PyGeodesy-24.4.4.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
+PyGeodesy-24.4.4.dist-info/top_level.txt,sha256=cEQPatCXzKZqrivpULC5V5fuy9_V_bAwaP_gUGid7pQ,10
+PyGeodesy-24.4.4.dist-info/RECORD,,

pygeodesy/__init__.py

@@ -133,7 +133,7 @@ U{geographiclib<https://PyPI.org/project/geographiclib>} 1.50, U{numpy<https://P
 1.16.6, U{scipy<https://PyPI.org/project/scipy>} 1.2.2, U{GeoConvert
 <https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.2, U{GeodSolve
 <https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.2 and U{RhumbSolve
-<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.2), all on macOS 14.3.1 Sonoma and
+<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.2), all on macOS 14.4.1 Sonoma and
 in 64-bit only.
 
 All tests ran with and without C{lazy import} for Python 3 and with command line option C{-W default} and
@@ -164,7 +164,7 @@ Previously, the tests were run with Python 3.12.0-1, 3.11.2-4, 3.10.1-7, 3.9.1,
 1.16.5, 1.16.2, 1.15.2, 1.14.0, 1.13.1, 1.8.0rc1 or 1.6.2 and U{scipy<https://PyPI.org/project/scipy>} 1.5.0), U{PyPy
 <https://PyPy.org>} 7.3.0 (Python 2.7.13 and 3.6.9), U{PyPy<https://PyPy.org>} 6.0.0 (Python 2.7.13 and 3.5.3)
 and U{Intel-Python<https://software.Intel.com/en-us/distribution-for-python>} 3.5.3 (and U{numpy
-<https://PyPI.org/project/numpy>} 1.11.3) on macOS 14.0-2.1 Sonoma, 13.0-5.2 Ventura, 12.1-6 Monterey, 11.0-5.2-6.1
+<https://PyPI.org/project/numpy>} 1.11.3) on macOS 14.0-3.1 Sonoma, 13.0-5.2 Ventura, 12.1-6 Monterey, 11.0-5.2-6.1
 Big Sur (aka 10.16), 10.15.3, 10.15.5-7 Catalina, 10.14 Mojave, 10.13.6 High Sierra and 10.12 Sierra, MacOS X
 10.11 El Capitan and/or MacOS X 10.10 Yosemite, with U{Pythonista<https://OMZ-Software.com/pythonista>}3.2 (with
 geographiclib 1.50 or 1.49 and numpy 1.8.0) on iOS 14.4.2, 11.4.1, 12.0-3 on iPad4, iPhone6, iPhone10 and/or
@@ -179,7 +179,7 @@ All Python source code has been statically U{checked<https://GitHub.com/ActiveSt
 Python/546532_PyChecker_postprocessor>} with U{PyChecker<https://PyPI.org/project/pychecker>}, U{PyFlakes
 <https://PyPI.org/project/pyflakes>}, U{PyCodeStyle<https://PyPI.org/project/pycodestyle>} (formerly Pep8) and
 U{McCabe<https://PyPI.org/project/mccabe>} using Python 2.7.18 and with U{Flake8<https://PyPI.org/project/flake8>}
-using Python 3.11.5, both in 64-bit on macOS 14.3.1 Sonoma.
+using Python 3.11.5, both in 64-bit on macOS 14.4.1 Sonoma.
 
 For a summary of all I{Karney}-based functionality in C{pygeodesy}, see module U{karney
 <https://mrJean1.GitHub.io/PyGeodesy/docs/pygeodesy.karney-module.html>}.
@@ -586,7 +586,7 @@ else:
     _init__all__ = False
 
 from pygeodesy.interns import _DOT_, _version2  # PYCHOK import
-__version__ = '24.04.02'
+__version__ = '24.04.04'
 # see setup.py for similar logic
 version     = _DOT_(*_version2(__version__, n=3))
 

pygeodesy/basics.py

@@ -14,21 +14,27 @@ if not division:
     raise ImportError('%s 1/2 == %s' % ('division', division))
 del division
 
+# from pygeodesy.cartesianBase import CartesianBase  # _MODS
+# from pygeodesy.constants import isneg0, NEG0  # _MODS
 from pygeodesy.errors import _AttributeError, _ImportError, _NotImplementedError, \
                              _TypeError, _TypesError, _ValueError, _xAssertionError, \
                              _xkwds_get
 from pygeodesy.interns import MISSING, NN, _1_, _by_, _COMMA_, _DOT_, _DEPRECATED_, \
                              _ELLIPSIS4_, _enquote, _EQUAL_, _in_, _invalid_, _N_A_, \
                              _not_scalar_, _SPACE_, _UNDER_, _version_, _version_info
+# from pygeodesy.latlonBase import LatLonBase  # _MODS
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS, \
                              _getenv, LazyImportError, _sys, _sys_version_info2
+# from pygeodesy.named import classname, modulename  # _MODS
+# from pygeodesy.nvectorBase import NvectorBase  # _MODS
+# from pygeodesy.props import _update_all  # _MODS
 
 from copy import copy as _copy, deepcopy as _deepcopy
 from math import copysign as _copysign
 import inspect as _inspect
 
 __all__ = _ALL_LAZY.basics
-__version__ = '24.04.01'
+__version__ = '24.04.04'
 
 _0_0                  =  0.0  # in .constants
 _below_               = 'below'
@@ -537,14 +543,19 @@ def neg_(*xs):
     return map(neg, xs)
 
 
-def _req_d_by(where, **name):  # in .basics
+def _neg0(x):
+    '''(INTERNAL) Return C{NEG0 if x < 0 else _0_0},
+       unlike C{_copysign_0_0} which returns C{_N_0_0}.
+    '''
+    return _MODS.constants.NEG0 if x < 0 else _0_0
+
+
+def _req_d_by(where, name=NN):  # in .basics
     '''(INTERNAL) Get the fully qualified name.
     '''
     m = _MODS.named.modulename(where, prefixed=True)
     if name:
-        n = _xkwds_get(name, name=NN)
-        if n:
-            m = _DOT_(m, n)
+        m = _DOT_(m, name)
     return _SPACE_(_required_, _by_, m)
 
 

pygeodesy/constants.py

@@ -23,7 +23,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '24.03.15'
+__version__ = '24.04.04'
 
 
 def _copysign_0_0(y):
@@ -137,7 +137,7 @@ def _over(p, q):
     '''(INTERNAL) Return C{B{p} / B{q}} avoiding C{ZeroDivisionError} exceptions.
     '''
     try:
-        return (p / q)
+        return (p / q)  # if p else _copysign_0_0(q)
     except ZeroDivisionError:
         return (_copysignINF(p) if isfinite(p) else NAN) if p else p
 

pygeodesy/fmath.py

@@ -8,9 +8,9 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import _copysign, copysign0, isint, len2
 from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
-                               _0_0, _0_125, _0_25, _0_5, _1_0, _N_1_0, \
-                               _1_3rd, _1_5, _1_6th, _2_0, _2_3rd, _3_0, \
-                               _isfinite, isnear1, _over, remainder
+                               _0_0, _0_125, _0_25, _0_5, _1_0, _1_3rd, \
+                               _1_5, _1_6th, _2_0, _2_3rd, _3_0, \
+                               _copysign_0_0, _isfinite, _over, remainder
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
                              _xError, _xkwds_get, _xkwds_pop2
 from pygeodesy.fsums import _2float, Fsum, _fsum, fsum, fsum1_, _pow_op_, \
@@ -25,7 +25,7 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '24.03.31'
+__version__ = '24.04.04'
 
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ... sqrt(2) - 1
@@ -116,8 +116,8 @@ class Fhypot(Fsum):
                 self._fpow(r, _pow_op_)
             else:
                 self._fset(_0_0)
-        except Exception as X:
-            raise self._ErrorX(X, xs, power=p)
+        except Exception as x:
+            raise self._ErrorXs(x, xs, power=p)
 
 
 class Fpolynomial(Fsum):
@@ -169,7 +169,7 @@ class Fpowers(Fsum):
             else:
                 self._fset(_0_0)
         except Exception as x:
-            raise self._ErrorX(x, xs, power=power)
+            raise self._ErrorXs(x, xs, power=power)
 
 
 class Fn_rt(Fsum):
@@ -193,7 +193,7 @@ class Fn_rt(Fsum):
             else:
                 self._fset(_0_0)
         except Exception as x:
-            raise self._ErrorX(x, xs, root=root)
+            raise self._ErrorXs(x, xs, root=root)
 
 
 class Fcbrt(Fn_rt):
@@ -359,7 +359,7 @@ def fatan1(x):
     # Eq (9): PI_4 * x - x * (abs(x) - 1) * (0.2447 + 0.0663 * abs(x)), for -1 < x < 1
     #         PI_4 * x - (x**2 - x) * (0.2447 + 0.0663 * x), for 0 < x - 1
     #         x * (1.0300981633974482 + x * (-0.1784 - x * 0.0663))
-    H = Fhorner(x, _0_0, 1.0300982, -0.1784, -0.0663)
+    H = Fhorner(x, _0_0, 1.0300981634, -0.1784, -0.0663)
     return float(H)
 
 
@@ -716,7 +716,7 @@ if _sys_version_info2 < (3, 8):  # PYCHOK no cover
                   computed as M{hypot_(*((c1 - c2) for c1, c2 in zip(p1, p2)))},
                   provided I{p1} and I{p2} have the same, non-zero length I{n}.
         '''
-        h, x2 = _h_x2(xs)
+        h, x2 = _h_x2(xs, hypot_)
         return (h * sqrt(x2)) if x2 else _0_0
 
 elif _sys_version_info2 < (3, 10):
@@ -747,22 +747,23 @@ else:
     hypot_ = hypot
 
 
-def _h_x2(xs):
+def _h_x2(xs, which):
     '''(INTERNAL) Helper for L{hypot_} and L{hypot2_}.
     '''
-    if xs:
-        n, xs = len2(xs)
-        if n > 0:
-            h = float(max(map(fabs, xs)))
-            if h < EPS0:
-                x2 = _0_0
-            elif h in (_1_0, _N_1_0):
-                x2 = _fsum(_1primed(x**2 for x in xs))
-            else:  # math.fsum
-                x2 = _fsum(_1primed((x / h)**2 for x in xs))
-            return h, x2
+    n, xs = len2(xs)
+    if n > 0:
+        h = float(max(map(fabs, xs)))
+        if h < EPS0:
+            x2 = _0_0
+        elif n > 1:
+            _h = (_1_0 / h) if h != _1_0 else _1_0
+            x2 = _fsum(_1primed((x * _h)**2 for x in xs))
+        else:
+            x2 = _1_0
+        return h, x2
 
-    raise _ValueError(xs=xs, txt=_too_(_few_))
+    t = Fmt.PAREN(which.__name__, xs)
+    raise _ValueError(t, txt=_too_(_few_))
 
 
 def hypot1(x):
@@ -783,15 +784,12 @@ def hypot2(x, y):
 
        @return: C{B{x}**2 + B{y}**2} (C{float}).
     '''
+    if fabs(x) < fabs(y):
+        x, y = y, x
     if x:
+        h2 = x**2
         if y:
-            if fabs(x) < fabs(y):
-                x, y = y, x
-            h2 = x**2 * ((y / x)**2 + _1_0)
-        else:
-            h2 = x**2
-    elif y:
-        h2 = y**2
+            h2 *= (y / x)**2 + _1_0
     else:
         h2 = _0_0
     return h2
@@ -810,7 +808,7 @@ def hypot2_(*xs):
 
        @see: Function L{hypot_}.
     '''
-    h, x2 = _h_x2(xs)
+    h, x2 = _h_x2(xs, hypot2_)
     return (h**2 * x2) if x2 else _0_0
 
 
@@ -840,14 +838,15 @@ def norm2(x, y):
        @raise ValueError: Invalid B{C{x}} or B{C{y}}
               or zero norm.
     '''
-    h = hypot(x, y)
-    if not h:
-        x = y = _0_0  # pass?
-    elif not isnear1(h):
-        try:
-            x, y = x / h, y / h
-        except Exception as e:
-            raise _xError(e, x=x, y=y, h=h)
+    try:
+        h = hypot(x, y)
+        if h:
+            x, y = (x / h), (y / h)
+        else:
+            x = _copysign_0_0(x)  # pass?
+            y = _copysign_0_0(y)
+    except Exception as e:
+        raise _xError(e, x=x, y=y, h=h)
     return x, y
 
 
@@ -861,16 +860,13 @@ def norm_(*xs):
        @raise ValueError: Invalid or insufficent B{C{xs}}
               or zero norm.
     '''
-    h = hypot_(*xs)
-    if h:
-        try:
-            for i, x in enumerate(xs):
-                yield x / h
-        except Exception as e:
-            raise _xError(e, Fmt.SQUARE(xs=i), x, _h_, h)
-    else:
-        for _ in xs:
-            yield _0_0
+    try:
+        h  = hypot_(*xs)
+        _h = (_1_0 / h) if h else _0_0
+        for i, x in enumerate(xs):
+            yield x * _h
+    except Exception as e:
+        raise _xError(e, Fmt.SQUARE(xs=i), x, _h_, h)
 
 
 def _powers(x, n):

pygeodesy/fsums.py

@@ -14,8 +14,8 @@ L{Fsum.__rpow__} return a (very long) C{int} if invoked with optional argument
 C{mod} set to C{None}.  The C{residual} of an C{integer} L{Fsum} may be between
 C{-1.0} and C{+1.0}, including C{INT0} if considered to be I{exact}.
 
-Set env variable C{PYGEODESY_FSUM_PARTIALS} to an empty string (or anything
-other than C{"fsum"}) for backward compatible summation of L{Fsum} partials.
+Set env variable C{PYGEODESY_FSUM_PARTIALS} to string C{"fsum"}) for summation
+of L{Fsum} partials by Python function C{math.fsum}.
 
 Set env variable C{PYGEODESY_FSUM_RESIDUAL} to a C{float} string greater
 than C{"0.0"} as the threshold to throw a L{ResidualError} in division or
@@ -46,7 +46,7 @@ from pygeodesy.props import _allPropertiesOf_n, deprecated_property_RO, \
 from math import ceil as _ceil, fabs, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '24.04.02'
+__version__ = '24.04.04'
 
 _add_op_       = _PLUS_  # in .auxilats.auxAngle
 _eq_op_        = _EQUAL_ * 2  # _DEQUAL_
@@ -81,8 +81,8 @@ def _2float(index=None, **name_value):  # in .fmath, .fstats
         if _isfinite(v):
             return v
         raise ValueError(_not_finite_)
-    except Exception as e:
-        raise _xError(e, Fmt.INDEX(n, index), v)
+    except Exception as X:
+        raise _xError(X, Fmt.INDEX(n, index), v)
 
 
 def _2floats(xs, origin=0, neg=False):
@@ -123,28 +123,28 @@ def _2ps(s, r):
 
 
 def _psum(ps):  # PYCHOK used!
-    '''(INTERNAL) Partials summation updating C{ps}, I{overridden below}.
+    '''(INTERNAL) Partials sum, updating C{ps}, I{overridden below}.
     '''
     # assert isinstance(ps, list)
-    i = len(ps) - 1  # len(ps) > 2
-    if i < 0:
-        return _0_0
-    s   =  ps[i]
+    i   =  len(ps) - 1
+    s   = _0_0 if i < 0 else ps[i]
     _2s = _2sum
     while i > 0:
         i -= 1
         s, r = _2s(s, ps[i])
         if r:  # sum(ps) became inexact
-            ps[i:] = (s, r) if s else (r,)
-            if i > 0:
-                p = ps[i-1]  # round half-even
-                if (p > 0 and r > 0) or \
-                   (p < 0 and r < 0):  # signs match
-                    r *= 2
-                    t  = s + r
-                    if r == (t - s):
-                        s = t
-            break
+            if s:
+                ps[i:] = r, s
+                if i > 0:
+                    p = ps[i-1]  # round half-even
+                    if (p > 0 and r > 0) or \
+                       (p < 0 and r < 0):  # signs match
+                        r *= 2
+                        t  = s + r
+                        if r == (t - s):
+                            s = t
+                break  # return s
+            s = r  # PYCHOK no cover
         ps[i:] = s,
     return s
 
@@ -168,24 +168,24 @@ def _2scalar(other, _raiser=None):
 
 
 def _strcomplex(s, *args):
-    '''(INTERNAL) C{Complex} 2- or 3-arg C{pow} error C{str}.
+    '''(INTERNAL) C{Complex} 2- or 3-arg C{pow} error as C{str}.
     '''
-    c =  iscomplex.__name__[2:]
+    c = _strcomplex.__name__[4:]
     n = _DASH_(len(args), _arg_)
-    t = _SPACE_(c, s, _from_, n, pow.__name__)
-    return unstr(t, *args)
+    t =  unstr(pow, *args)
+    return _SPACE_(c, s, _from_, n, t)
 
 
 def _stresidual(prefix, residual, **name_values):
-    '''(INTERNAL) Residual error C{str}.
+    '''(INTERNAL) Residual error as C{str}.
     '''
-    p = _SPACE_(prefix, Fsum.residual.name)
+    p = _stresidual.__name__[3:]
     t =  Fmt.PARENSPACED(p, Fmt(residual))
     for n, v in itemsorted(name_values):
         n =  n.replace(_UNDER_, _SPACE_)
         p =  Fmt.PARENSPACED(n, Fmt(v))
         t = _COMMASPACE_(t, p)
-    return t
+    return _SPACE_(prefix, t)
 
 
 def _2sum(a, b):  # by .testFmath
@@ -219,8 +219,8 @@ def _2yield(xs, i, _X_ps, _x):
                         raise ValueError(_not_finite_)
                     yield f
             i += 1
-    except Exception as e:
-        raise _xError(e, Fmt.INDEX(xs=i), x)
+    except Exception as X:
+        raise _xError(X, Fmt.INDEX(xs=i), x)
 
 
 class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
@@ -756,14 +756,14 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
     def _cmp_0(self, other, op):
         '''(INTERNAL) Return C{scalar(self - B{other})} for 0-comparison.
         '''
-        if isscalar(other):
+        if isinstance(other, Fsum):
+            s = _fsum(self._ps_1(*other._ps))
+        elif isscalar(other):
             if other:
                 s = _fsum(self._ps_1(other))
             else:
                 s, r = self._fprs2
                 s = _signOf(s, -r)
-        elif isinstance(other, Fsum):
-            s = _fsum(self._ps_1(*other._ps))
         else:
             raise self._TypeError(op, other)  # txt=_invalid_
         return s
@@ -816,13 +816,21 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         f = self._copy_2(self.divmod)
         return f._fdivmod2(other, _divmod_op_)
 
-    def _Error(self, op, other, Error, **txt):
+    def _Error(self, op, other, Error, **txt_cause):
         '''(INTERNAL) Format an B{C{Error}} for C{{self} B{op} B{other}}.
         '''
-        return Error(_SPACE_(self.toRepr(), op, repr(other)), **txt)
+        return Error(_SPACE_(self.toRepr(), op, repr(other)), **txt_cause)
 
-    def _ErrorX(self, X, xs, **kwds):  # in .fmath
-        '''(INTERNAL) Format a caught exception.
+    def _ErrorX(self, X, op, other, *mod):
+        '''(INTERNAL) Format the caught exception C{X}.
+        '''
+        E, t = _xError2(X)
+        if mod:
+            t = _COMMASPACE_(Fmt.PARENSPACED(mod=mod[0]), t)
+        return self._Error(op, other, E, txt=t, cause=X)
+
+    def _ErrorXs(self, X, xs, **kwds):  # in .fmath
+        '''(INTERNAL) Format the caught exception C{X}.
         '''
         E, t = _xError2(X)
         n = unstr(self.named3, *xs[:3], _ELLIPSIS=len(xs) > 3, **kwds)
@@ -834,13 +842,14 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         n, ps, _2s = 0, self._ps, _2sum
         for x in xs:  # _iter()
             # assert isscalar(x) and isfinite(x)
-            i = 0
-            for p in ps:
-                x, p = _2s(x, p)
-                if p:
-                    ps[i] = p
-                    i += 1
-            ps[i:] = x,
+            if x:
+                i = 0
+                for p in ps:
+                    x, p = _2s(x, p)
+                    if p:
+                        ps[i] = p
+                        i += 1
+                ps[i:] = (x,) if x else ()
             n += 1
         # assert self._ps is ps
         if n:
@@ -858,30 +867,29 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
     def _facc_power(self, power, xs, which):  # in .fmath
         '''(INTERNAL) Add each C{xs} as C{float(x**power)}.
         '''
-        if isinstance(power, Fsum):
-            if power.is_exact:
-                return self._facc_power(power._fprs, xs, which)
+        p = power
+        if isinstance(p, Fsum):
+            if p.is_exact:
+                return self._facc_power(p._fprs, xs, which)
             _Pow = Fsum._pow_any
-        elif isint(power, both=True) and power >= 0:
-            _Pow = Fsum._pow_int
-            power = int(power)
+        elif isint(p, both=True) and p >= 0:
+            _Pow, p = Fsum._pow_int, int(p)
         else:
-            _Pow = Fsum._pow_scalar
-            power = _2float(power=power)
+            _Pow, p = Fsum._pow_scalar, _2float(power=p)
 
-        if power:
+        if p:
             from math import pow as _pow
             op = which.__name__
 
             def _X(X):
-                f = _Pow(X, power, power, op)
+                f = _Pow(X, p, power, op)
                 try:  # isinstance(f, Fsum)
                     return f._ps
                 except AttributeError:  # scalar
                     return f,
 
             def _x(x):
-                return _pow(float(x), power)
+                return _pow(float(x), p)
 
             self._facc(_2yield(xs, 1, _X, _x))  # PYCHOK yield
         else:
@@ -985,7 +993,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         '''
         if _isfinite(other):
             return other
-        raise ValueError(_not_finite_) if not op else \
+        raise ValueError(_not_finite_) if op is None else \
               self._ValueError(op, other, txt=_not_finite_)
 
     def fint(self, raiser=True, **name):
@@ -1123,11 +1131,11 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
            running sum and residual (L{Fsum2Tuple}).
         '''
         ps = self._ps
-        n  = len(ps)
-        if n > 2:  # len(ps) > 2
+        n  = len(ps) - 2
+        if n > 0:  # len(ps) > 2
             s = _psum(ps)
             r = _fsum(self._ps_1(s)) or INT0
-        elif n > 1:  # len(ps) == 2
+        elif n == 0:  # len(ps) == 2
             ps[:] = _2ps(*_2sum(*ps))
             r, s  = (INT0, ps[0]) if len(ps) != 2 else ps
         elif ps:  # len(ps) == 1
@@ -1145,6 +1153,20 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
 #           _ = self._fprs
 #       return self
 
+    def fset_(self, *xs):
+        '''Replace this instance' value with C{xs}.
+
+           @arg xs: Optional, new values (C{scalar} or L{Fsum}
+                    instances), all positional.
+
+           @return: This instance (C{Fsum}).
+
+           @see: Method L{Fsum.fadd} for further details.
+        '''
+        self._n = 0
+        self._ps[:] = 0,
+        return self.fadd(xs) if xs else self._update()
+
     def _fset(self, other, asis=True, n=0):
         '''(INTERNAL) Overwrite this instance with an other or a C{scalar}.
         '''
@@ -1249,7 +1271,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         f = self._facc(_2floats(xs, origin=1)) if xs else self  # PYCHOK yield
         return f._fprs
 
-    def fsum2(self, xs=(), **name):
+    def fsum2(self, xs=(), name=NN):
         '''Add more C{scalar} or L{Fsum} instances and return the
            current precision running sum and the C{residual}.
 
@@ -1268,9 +1290,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         f = self._facc(_2floats(xs)) if xs else self  # PYCHOK yield
         t = f._fprs2
         if name:
-            n = _xkwds_get(name, name=NN)
-            if n:
-                t = t.dup(name=n)
+            t = t.dup(name=name)
         return t
 
     def fsum2_(self, *xs):
@@ -1306,16 +1326,16 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         '''
         n = _1_0
         if isinstance(other, Fsum):
-            if other is self or other._fprs2 == self._fprs2:
+            if other is self or other == self:
                 return self._fset(_1_0)  # n=len(self)
             d, r = other._fprs2
             if r:
-                if not d:  # PYCHOK no cover
-                    d = r
-                elif self._raiser(r, d):
-                    raise self._ResidualError(op, other, r)
-                else:
+                if d:
+                    if self._raiser(r, d):
+                        raise self._ResidualError(op, other, r)
                     d, n = other.as_integer_ratio()
+                else:  # PYCHOK no cover
+                    d = r
         elif isscalar(other):
             d = other
         else:  # PYCHOK no cover
@@ -1323,9 +1343,8 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         try:
             s = 0 if isinf(d) else (
                 d if isnan(d) else self._finite(n / d))
-        except Exception as x:
-            E, t = _xError2(x)
-            raise self._Error(op, other, E, txt=t)
+        except Exception as X:
+            raise self._ErrorX(X, op, other)
         f = self._mul_scalar(s, _mul_op_)  # handles 0, NAN, etc.
         return self._fset(f, asis=False)
 
@@ -1444,7 +1463,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
     def _pow_0_1(self, x, other):
         '''(INTERNAL) Return B{C{self}**1} or C{B{self}**0 == 1.0}.
         '''
-        return self if x else (1 if self.is_integer() and isint(other) else _1_0)
+        return self if x else (1 if isint(other) and self.is_integer() else _1_0)
 
     def _pow_2(self, b, x, other, op):
         '''(INTERNAL) 2-arg C{pow(B{b}, scalar B{x})} embellishing errors.
@@ -1455,10 +1474,9 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
             if not iscomplex(s):
                 return self._finite(s)  # 0**INF == 0.0, 1**INF==1.0
             # neg**frac == complex in Python 3+, but ValueError in 2-
-            E, t = _ValueError, _strcomplex(s, b, x)  # PYCHOK no cover
-        except Exception as x:
-            E, t = _xError2(x)
-        raise self._Error(op, other, E, txt=t)
+            raise ValueError(_strcomplex(s, b, x))  # PYCHOK no cover
+        except Exception as X:
+            raise self._ErrorX(X, op, other)
 
     def _pow_3(self, other, mod, op):
         '''(INTERNAL) 3-arg C{pow(B{self}, B{other}, int B{mod} or C{None})}.
@@ -1466,19 +1484,18 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         b, r = self._fprs2 if mod is None else self._fint2
         if r and self._raiser(r, b):
             t = _non_zero_ if mod is None else _integer_
-            E, t = ResidualError, _stresidual(t, r, mod=mod)
-        else:
-            try:  # b, other, mod all C{int}, unless C{mod} is C{None}
-                x = _2scalar(other, _raiser=self._raiser)
-                s =  pow(b, x, mod)
-                if not iscomplex(s):
-                    return self._finite(s)
-                # neg**frac == complex in Python 3+, but ValueError in 2-
-                E, t = _ValueError, _strcomplex(s, b, x, mod)  # PYCHOK no cover
-            except Exception as x:
-                E, t = _xError2(x)
-                t = _COMMASPACE_(Fmt.PARENSPACED(mod=mod), t)
-        raise self._Error(op, other, E, txt=t)
+            t = _stresidual(t, r, mod=mod)
+            raise self._Error(op, other, ResidualError, txt=t)
+
+        try:  # b, other, mod all C{int}, unless C{mod} is C{None}
+            x = _2scalar(other, _raiser=self._raiser)
+            s =  pow(b, x, mod)
+            if not iscomplex(s):
+                return self._finite(s)
+            # neg**frac == complex in Python 3+, but ValueError in 2-
+            raise ValueError(_strcomplex(s, b, x, mod))  # PYCHOK no cover
+        except Exception as X:
+            raise self._ErrorX(X, op, other, mod)
 
     def _pow_any(self, other, unused, op):
         '''Return C{B{self} ** B{other}}.
@@ -1569,14 +1586,15 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
     def _ps_1(self, *less):
         '''(INTERNAL) Yield partials, 1-primed and subtract any C{less}.
         '''
-        yield _1_0
+        n = len(self._ps) + len(less) - 4
+        if n < 0:
+            yield _1_0
         for p in self._ps:
-            if p:
-                yield p
+            yield p
         for p in less:
-            if p:
-                yield -p
-        yield _N_1_0
+            yield -p
+        if n < 0:
+            yield _N_1_0
 
     def _ps_mul(self, op, *factors):  # see .fmath.Fhorner
         '''(INTERNAL) Yield all C{partials} times each B{C{factor}},
@@ -1636,12 +1654,12 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
                            C{PYGEODESY_FSUM_RESIDUAL} or if omitted, keep the
                            current setting.
 
-           @return: The previous C{RESIDUAL} setting (C{float}).
+           @return: The previous C{RESIDUAL} setting (C{float}), default C{0}.
 
            @raise ValueError: Negative B{C{threshold}}.
 
            @note: A L{ResidualError} is thrown if the non-zero I{ratio}
-                  C{residual} / C{fsum} exceeds the B{C{threshold}}.
+                  C{residual / fsum} exceeds the B{C{threshold}}.
         '''
         r = self._RESIDUAL
         if threshold:
@@ -1659,7 +1677,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
         '''(INTERNAL) Non-zero B{C{residual}} etc.
         '''
         t = _stresidual(_non_zero_, residual, ratio=self._ratio,
-                                            RESIDUAL=self._RESIDUAL)
+                                           RESIDUAL=self._RESIDUAL)
         t =  t.replace(_COMMASPACE_R_, _exceeds_R_)
         return self._Error(op, other, ResidualError, txt=t)
 
@@ -1721,7 +1739,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase
 #           Fsum._fint2._update(self)
 #           Fsum._fprs ._update(self)
 #           Fsum._fprs2._update(self)
-        return self
+        return self  # for .fset_
 
     def _ValueError(self, op, other, **txt):  # PYCHOK no cover
         '''(INTERNAL) Return a C{ValueError}.
@@ -1820,7 +1838,7 @@ try:
 
     Fsum._math_fsum = _sum = _fsum  # PYCHOK exported
 
-    if _getenv('PYGEODESY_FSUM_PARTIALS', _fsum.__name__) == _fsum.__name__:
+    if _getenv('PYGEODESY_FSUM_PARTIALS', NN) == _fsum.__name__:
         _psum = _fsum  # PYCHOK re-def
 
 except ImportError:
@@ -1915,6 +1933,35 @@ def fsum1f_(*xs):
     return _fsum(_1primed(xs)) if xs else _0_0
 
 
+if __name__ == '__main__':
+
+    # usage: [env PYGEODESY_FSUM_PARTIALS=fsum] python3 -m pygeodesy.fsums
+
+    def _test(n):
+        # copied from Hettinger, see L{Fsum} reference
+        from pygeodesy import printf
+        from random import gauss, random, shuffle
+
+        printf(_fsum.__name__, end=_COMMASPACE_)
+        printf(_psum.__name__, end=_COMMASPACE_)
+
+        F = Fsum()
+        if F.is_math_fsum:
+            c = (7, 1e100, -7, -1e100, -9e-20, 8e-20) * 10
+            for _ in range(n):
+                t = list(c)
+                s = 0
+                for _ in range(n * 8):
+                    v = gauss(0, random())**7 - s
+                    t.append(v)
+                    s += v
+                shuffle(t)
+                assert float(F.fset_(*t)) == _fsum(t)
+                printf(_DOT_, end=NN)
+        printf(NN)
+
+    _test(128)
+
 # **) MIT License
 #
 # Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.

pygeodesy/resections.py

@@ -13,9 +13,10 @@ L{triAngle}, L{triAngle5}, L{triSide}, L{triSide2} and L{triSide4}.
 from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import map1, map2, _zip,  _ALL_LAZY
-from pygeodesy.constants import EPS, EPS0, EPS02, INT0, NEG0, PI, PI2, PI_2, PI_4, \
-                               _0_0, _0_5, _1_0, _N_1_0, _2_0, _N_2_0, _4_0, _16_0, \
-                               _180_0, _360_0, isnear0, _over, _umod_360
+from pygeodesy.constants import EPS, EPS0, EPS02, INT0, PI, PI2, PI_2, PI_4, \
+                               _0_0, _0_5, _1_0, _N_1_0, _2_0, _N_2_0, _4_0, \
+                               _16_0, _180_0, _360_0, _copysign_0_0, isnear0, \
+                               _over, _umod_360
 from pygeodesy.errors import _and, _or, TriangleError, _ValueError, _xcallable, \
                              _xkwds, _xkwds_pop2
 from pygeodesy.fmath import favg, Fdot, fidw, fmean, hypot, hypot2_
@@ -33,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.03.26'
+__version__ = '24.04.04'
 
 _concyclic_ = 'concyclic'
 _PA_        = 'PA'
@@ -457,7 +458,7 @@ def pierlotx(point1, point2, point3, alpha1, alpha2, alpha3, useZ=False,
 
     def _cot(s, c):  # I{exact} cotangent
         try:
-            return (c / s) if c else (NEG0 if s < 0 else _0_0)
+            return (c / s) if c else _copysign_0_0(s)
         except ZeroDivisionError:
             raise ValueError(_or(_coincident_, _colinear_))
 

pygeodesy/utily.py

@@ -10,12 +10,14 @@ U{Vector-based geodesy<https://www.Movable-Type.co.UK/scripts/latlong-vectors.ht
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _copysign, isinstanceof, isint, isstr, neg, _passargs
-from pygeodesy.constants import EPS, EPS0, INF, NAN, NEG0, PI, PI2, PI_2, R_M, \
-                               _float as _F, _isfinite, isnan, isnear0, _over, \
-                               _umod_360, _umod_PI2, _M_KM, _M_NM, _M_SM, _0_0, \
-                               _1__90, _0_5, _1_0, _N_1_0, _2__PI, _10_0, _90_0, \
-                               _N_90_0, _180_0, _N_180_0, _360_0, _400_0
+from pygeodesy.basics import _copysign, isinstanceof, isint, isstr, neg, \
+                             _passargs
+from pygeodesy.constants import EPS, EPS0, INF, NAN, PI, PI2, PI_2, R_M, \
+                               _M_KM, _M_NM, _M_SM, _0_0, _1__90, _0_5, _1_0, \
+                               _N_1_0, _2__PI, _10_0, _90_0, _N_90_0, _180_0, \
+                               _N_180_0, _360_0, _400_0, _copysign_0_0, \
+                               _float as _F, _isfinite, isnan, isnear0, \
+                               _over, _umod_360, _umod_PI2
 from pygeodesy.errors import _ValueError, _xkwds, _xkwds_get,  _ALL_LAZY, _MODS
 from pygeodesy.interns import _edge_, _radians_, _semi_circular_, _SPACE_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .errors
@@ -25,7 +27,7 @@ from pygeodesy.units import Degrees, Degrees_, Feet, Float, Lam, Lam_, \
 from math import acos, asin, atan2, cos, degrees, fabs, radians, sin, tan  # pow
 
 __all__ = _ALL_LAZY.utily
-__version__ = '24.01.12'
+__version__ = '24.04.04'
 
 # read constant name "_M_Unit" as "meter per Unit"
 _M_CHAIN     = _F(  20.1168)     # yard2m(1) * 22
@@ -683,7 +685,7 @@ def _sin0cos2(q, r, sign):
 #   else:  # r == 0, testUtility failures
 #       t = _0_0, _1_0, _0_0, _N_1_0, _0_0
 #   q &= 3
-    s = t[q]     or (NEG0 if sign < 0 else _0_0)
+    s = t[q]     or _copysign_0_0(sign)
     c = t[q + 1] or _0_0
     return s, c
 
@@ -691,8 +693,7 @@ def _sin0cos2(q, r, sign):
 def SinCos2(x):
     '''Get C{sin} and C{cos} of I{typed} angle.
 
-       @arg x: Angle (L{Degrees}, L{Degrees_}, L{Radians}, L{Radians_}
-               or scalar C{radians}).
+       @arg x: Angle (L{Degrees}, L{Radians} or scalar C{radians}).
 
        @return: 2-Tuple (C{sin(B{x})}, C{cos(B{x})}).
     '''