wehub-resource-sync
1342 lines
59 KiB
Plaintext
1342 lines
59 KiB
Plaintext
--1.5.0--
|
|
Released TBD
|
|
|
|
Features:
|
|
|
|
* Support special numbers in mpf_frexp() like math.frexp(),
|
|
see #1081 (Sergey B Kirpichev)
|
|
* Add ModAB rootfinding algorithm, see #1093 (Ayush Baranwal)
|
|
* Add Brent root-finding algorithm, see #1103 (Ayush Baranwal)
|
|
* Correct integral path of the lerchphi() to use Laplace transform
|
|
integral, see #1109 (Sergey B Kirpichev)
|
|
|
|
Compatibility:
|
|
|
|
* Drop support for CPython 3.9, see #1058 (Sergey B Kirpichev)
|
|
* Remove deprecated math2 and rational modules, see #1057 (Sergey B Kirpichev)
|
|
* Remove deprecated mp.mpnumeric alias, see #1057 (Sergey B Kirpichev)
|
|
* Remove deprecated bitcount(), fp.is_special() and to/from_pickable()
|
|
functions, see #1057 (Sergey B Kirpichev)
|
|
* Drop DeprecationWarning for force_type kwarg for matrix(),
|
|
see #1057 (Sergey B Kirpichev)
|
|
* Use signed=True per default in to_man_exp(), see #1057 (Sergey B Kirpichev)
|
|
* Use asc=True per default for polynomial functions, see
|
|
#1057 (Sergey B Kirpichev)
|
|
* Restrict libmp exports to public API, see #1089 (Sergey B Kirpichev)
|
|
|
|
Bug fixes:
|
|
|
|
* Fix test_hexadecimal_with_libc_bulk(), see #1049 (Doug Torrance)
|
|
* Keep available deprecated aliases for mpc/mpf_log() (Sergey B Kirpichev)
|
|
* Use version_file option of setuptools-scm to keep version info, see #1048
|
|
(Sergey B Kirpichev)
|
|
* Add workaround for test on s390x, see #1061 (Sergey B Kirpichev)
|
|
* Fix signature of root(), see #1072 (Sergey B Kirpichev)
|
|
* Speedup removal trailing zeros in _normalize/from_man_exp(), see #1074
|
|
(Fredrik Johansson and Sergey B Kirpichev)
|
|
* Improve documentation about rounding in the mp context,
|
|
see #1079 (Sergey B Kirpichev)
|
|
* Correct to_float() conversion for double-rounding cases (e.g. subnormals),
|
|
see #1082 (Sergey B Kirpichev)
|
|
* Fix qr_solve() failure on well-conditioned matrices with zero pivot, see
|
|
#1083 (Jam Balaya)
|
|
* Clarify to_float() docstring, see #1087 (Sergey B Kirpichev)
|
|
* Add extra precision for summation in mpf_hypot(), see
|
|
#1088 (Sergey B Kirpichev)
|
|
* Fix typo and function names for sin/cospi(), see #1091 (Sergey B Kirpichev)
|
|
* Raise ValueError when same sign at interval boundaries in bisection
|
|
rootfinding algorithm, see #1092 (Ayush Baranwal)
|
|
* Correct interval update for Ridder's method, see #1096 (Sergey B Kirpichev)
|
|
* Set dynamic maxsteps value for the bisect method, see
|
|
#1096 (Sergey B Kirpichev)
|
|
* Implement direct series for lerchphi() base case with |z| < 1,
|
|
see #1100 (Sergey B Kirpichev)
|
|
* Correct exception message for THETA_Q_LIM, see #1102
|
|
(Sergey B Kirpichev and Jam Balaya)
|
|
* Fix gegenbauer() failing to converge for odd integer n at z=0,
|
|
see #1101 (Vincent Gao)
|
|
* Reorganize fixed-precision computations for theta3 to avoid
|
|
severe cancellation, see #1107 (Sergey B Kirpichev)
|
|
|
|
Maintenance:
|
|
|
|
* Add bash script to test package version in a frozen application version
|
|
and a separate CI job to run it, see #1055 (flurin4)
|
|
* Revert "Add backport action", see #1063 (Sergey B Kirpichev)
|
|
* Test on CPython 3.15, see #1071, #1106 and #1110 (Sergey B Kirpichev)
|
|
* Add AI-related policy, see #1098 (Sergey B Kirpichev)
|
|
* Fix test_sn_cn_dn_identities(), see #1106 (Sergey B Kirpichev)
|
|
* Fix test_compatibility(): avoid using of private numpy
|
|
API (Sergey B Kirpichev)
|
|
|
|
|
|
--1.4.1--
|
|
Released March 15, 2026
|
|
|
|
Bug fixes:
|
|
|
|
* Fix test_hexadecimal_with_libc_bulk(), see #1049 (Doug Torrance)
|
|
* Keep available deprecated aliases for mpc/mpf_log() (Sergey B Kirpichev)
|
|
* Use version_file option of setuptools-scm to keep version info, see #1048
|
|
(Sergey B Kirpichev)
|
|
* Add workaround for test on s390x, see #1061 (Sergey B Kirpichev)
|
|
|
|
|
|
--1.4.0--
|
|
Released February 23, 2026
|
|
|
|
Features:
|
|
|
|
* Support underscores as digit separators per PEP 515, see #661 (Sergey B
|
|
Kirpichev)
|
|
* Add rationals converter for mpf's, see #666 (Sergey B Kirpichev)
|
|
* Rewrite bernpoly/eulerpoly to avoid dependency on bernoulli(1) convention,
|
|
see #700 (Sergey B Kirpichev)
|
|
* Support base kwarg for from_str(), see #703 (Jonathan Warner, Sergey B
|
|
Kirpichev)
|
|
* Support randmatrix() for mp.iv and mp contexts, see #527 (Maximilian
|
|
Gaukler)
|
|
* Added rank() function for matrices, see #610 (Jan-Philipp Hoffmann)
|
|
* Add plus flag to select the B_1 sign convention for bernoulli/bernfrac, see
|
|
#724 (Jeremy Tan Jie Rui, Sergey B Kirpichev)
|
|
* Add mpf.as_integer_ratio() method, support construction of mpf from Decimal
|
|
objects, see #731 (Sergey B Kirpichev)
|
|
* Expose lower/upper_gamma functions, see #740 (Sergey B Kirpichev)
|
|
* Support mpc initialization from string, see #743 (Sergey B Kirpichev)
|
|
* Support asinh/acosh/atanh in the fp context, see #750 (Sergey B Kirpichev)
|
|
* Support binary/octal/hexadecimal string output, see #711 (Jonathan Warner,
|
|
Sergey B Kirpichev)
|
|
* Support pickling for matrices and mpi, see #761 (Sergey B Kirpichev)
|
|
* Support matrix.__array__() dunder method, see #767 (Sergey B Kirpichev)
|
|
* Support more number syntaxes, see #778 (Sergey B Kirpichev)
|
|
* Run mpmath as a module for interactive work, see #773, #923, #931, #936,
|
|
#939 and #954 (Sergey B Kirpichev)
|
|
* Add signed option to to_man_exp(), see #783 (Sergey B Kirpichev)
|
|
* Add fp.hypot, see #798 (Sergey B Kirpichev)
|
|
* Support inf/nan's in ctx.almosteq(), #802 (Sergey B Kirpichev)
|
|
* Implement mpf.__format__(), see #819, #831, #850, #859, #857, #862, #881,
|
|
#944 and #966 (Javier Garcia, Sergey B Kirpichev)
|
|
* Support conversion from scalar ndarray's, see #821 (Sergey B Kirpichev)
|
|
* Support rounding modes in mpf.__format__, see #823, #831, #834
|
|
and #969 (Javier Garcia, Sergey B Kirpichev)
|
|
* Support '%' presentation type for mpf, see #847 (Sergey B Kirpichev)
|
|
* Support gmpy2-like rounding modes in to_str(), see #830 (Javier Garcia)
|
|
* Implement 'a'/'A' formating types for mpf.__format__, see #841 and #870
|
|
(Sergey B Kirpichev)
|
|
* Add mpc.__format__(), see #855 (Sergey B Kirpichev)
|
|
* Now mpf.__round__() returns mpf, see #826 and #966 (Sergey B Kirpichev)
|
|
* Support 'b' (binary) format type for mpf/mpc, see #867 (Sergey B Kirpichev)
|
|
* Implement mpf.__floordiv__() and mpf.__divmod__(), see #873 (Sergey B
|
|
Kirpichev)
|
|
* Add parameters for MPContext constructor, see #876 and #963 (Sergey B Kirpichev)
|
|
* Add MPFR-compatible aliases for rounding modes, see #892 (Sergey B
|
|
Kirpichev)
|
|
* Support negative indexes in matrix, see #897 (Riccardo Orsi)
|
|
* Better introspection support for decorated functions, see #900 (Sergey B
|
|
Kirpichev)
|
|
* Add moving sofa demo, see #924 (Sergey B Kirpichev)
|
|
* Support spherical Bessel functions (jn/yn), #935 (Sergey B Kirpichev)
|
|
* Add pretty_dps context property to control number of printed digits, see
|
|
#933 (Sergey B Kirpichev)
|
|
* Support thousands separators for formatting of fractional part, see #925 and
|
|
#936 (Sergey B Kirpichev)
|
|
* Use PyREPL, as fallback (no IPython), see #941 (Sergey B Kirpichev)
|
|
* Add exp2() and log2(), see #948 (Sergey B Kirpichev)
|
|
* Support rounding property for the mp context, see #963 (Sergey B Kirpichev)
|
|
* Add Fox H-function with rational A/B parameters (foxh()), see #982 (Hongren Zheng)
|
|
* Provide experimental support for free-threading builds, see #993 (Sergey B Kirpichev)
|
|
|
|
Compatibility:
|
|
|
|
* Drop Python 2 support, see #629 (Fangchen Li)
|
|
* Drop support for Python versions < 3.9, see #675 and #911 (Sergey B Kirpichev)
|
|
* Drop private mpq class, use Rational's, provided by backend, see #691 and
|
|
#769 (Sergey B Kirpichev)
|
|
* Drop to_pickable()/from_pickable() helpers, see #667 and #769 (Sergey B
|
|
Kirpichev)
|
|
* Direct access to _mpf_ tuples now deprecated, please use from/to_man_exp()
|
|
functions and special constants (finf, fninf and fnan), see
|
|
#783 (Sergey B Kirpichev)
|
|
* Removed sage backend, see #732 (Sergey B Kirpichev)
|
|
* Drop MPMATH_STRICT environment variable, see #759 (Sergey B Kirpichev)
|
|
* Deprecate current (descending) order of coefficients in polyval(), etc, see
|
|
#779, #844 and #845 (Sergey B Kirpichev, Warren Weckesser)
|
|
* Deprecate mpmath.math2, see #769 (Sergey B Kirpichev)
|
|
* Importing from the mpmath.libmp submodules is deprecated, use instead ``from
|
|
mpmath.libmp import foo``, see
|
|
issue https://github.com/mpmath/mpmath/issues/704#issuecomment-2953536980
|
|
for available functions (Sergey B Kirpichev)
|
|
* Deprecate bitcount function, see #721 and #955 (Sergey B Kirpichev)
|
|
* Deprecate mpf/mpc_log, see #989 (Sergey B Kirpichev)
|
|
* Deprecate fp.is_special(), see #1042 (Sergey B Kirpichev)
|
|
|
|
Bug fixes:
|
|
|
|
* sum_accurately(), betainc() and power() fixes, see #664 (Sergey B Kirpichev)
|
|
* Warn users about Python's true division, see #670 (Sergey B Kirpichev)
|
|
* Propagate nan's in ei_asympt(), see #672 (Sergey B Kirpichev)
|
|
* Fix matrix.__eq__, fix string parsing with underscores, see #679 (Sergey B
|
|
Kirpichev)
|
|
* Raise IndexError if matrix index out of bounds, see #689 (Sergey B
|
|
Kirpichev)
|
|
* Fix nan handling in fp.mag() and hyper(), see #688 (Sergey B Kirpichev)
|
|
* Optimize sparse matrix dot product, see #450 (Tyler Chen)
|
|
* Correct pow() for mpf's to be consistent with mpfr/float's, see #690 (Sergey
|
|
B Kirpichev)
|
|
* Improve hypsum non-convergence behaviour, see #703 (Benjamin Fischer)
|
|
* Fixed TypeError in LU_comp, see #610 (Jan-Philipp Hoffmann)
|
|
* Fix disagreement fp.mod vs mp.mod, see #710 (Sergey B Kirpichev)
|
|
* Skip eigenvectors if left=right=False for one-dimentional matrix, see #713
|
|
(Sergey B Kirpichev)
|
|
* Fix mpc() constructor to be compatible with complex(), fix disagreement
|
|
fp.pow vs mp.pow, see #731 (Sergey B Kirpichev)
|
|
* Add derivative keyword argument for besselk(), see #735 (Sergey B Kirpichev)
|
|
* Fix quadosc(), fast case in _hyp2f1(), correct fp.gamma() and fp.isnprint(),
|
|
see #740 (Sergey B Kirpichev)
|
|
* Pevent erroneous setting of dps/prec on mpmath module, see #678
|
|
(Colin B. Macdonald)
|
|
* Update splot() for recent matplotlib, see #747 (Sergey B Kirpichev)
|
|
* acos_asin(): don't try to normalize special numbers, fix repr(mp.eps), see
|
|
#750 (Sergey B Kirpichev)
|
|
* Fix choleksy_solve for complex matrix, see #755 (Qiming Sun)
|
|
* Fix hang in polylog_general(), fix demos, use cholesky_solve() for
|
|
overdetermined complex linear systems, fix several issues with empty
|
|
matrices, see #759
|
|
* sqrt(z): special case for infinite z.imag, see #777 (Sergey B Kirpichev)
|
|
* Correct atan2(±inf, ±inf), see #775 (Sergey B Kirpichev)
|
|
* Handle infinite arguments in tan/tanh, see #785 (Sergey B Kirpichev)
|
|
* Drop mpf.__complex__(), workaround 1/z division for acot/asec/acsc/acoth,
|
|
see #797 (Sergey B Kirpichev)
|
|
* Handle more special cases in besselk and hyp1f1, see #792, #800 and #801
|
|
(Sergey B Kirpichev)
|
|
* Correct asin/acos for infinite arguments, see #795 (Sergey B Kirpichev)
|
|
* Reduce memory usage for QuadratureRule cache, see #812 (Sergey B Kirpichev)
|
|
* Drop sign from nstr(mpf('inf')) output, see #828 (Sergey B Kirpichev)
|
|
* Improve accuracy of log1p(), see #803 and #854 (Tim Peters, Sergey B
|
|
Kirpichev)
|
|
* Normalize mpf in mp.npconvert(), fix special cases in bernpoly(), see #839
|
|
(Sergey B Kirpichev)
|
|
* Fix mpf_div() for prec=0, see #849 (Sergey B Kirpichev)
|
|
* Raise ValueError for complex infininity condition in zeta(s, a), see #864
|
|
(Sergey B Kirpichev)
|
|
* Enable trap_complex for MDNewton, see #870 (Sergey B Kirpichev)
|
|
* Use correct mixed-mode functions in fsub/fdiv, add special cases for
|
|
infinities in mpc_*div(), see #873 (Sergey B Kirpichev)
|
|
* Revert "fix ellippi to return an inf instead of raising an exception", see
|
|
#875 (Sergey B Kirpichev)
|
|
* Reject invalid strings in from_str(), see #886 (Sergey B Kirpichev)
|
|
* Use parity formula for besseli, see #889 (Sergey B Kirpichev)
|
|
* Special case in ctx.hypsum for infinite z, see #902 (Sergey B Kirpichev)
|
|
* Raise an exception if iv's comparison can't be decided, see #903 (Sergey B
|
|
Kirpichev)
|
|
* Add special case for ±inf in polylog_continuation(), see #904, #1034
|
|
and #1037 (Sergey B Kirpichev, Colin B. Macdonald)
|
|
* Increase working precision in polylog_general() for negative s, see #898
|
|
(Sergey B Kirpichev)
|
|
* Correct case for integer n in besselj/besseli, see #909 (Sergey B Kirpichev)
|
|
* Use sum_accurately() in hankel1/2(), see #926 (Sergey B Kirpichev)
|
|
* Ensure mpf_bernoulli() returns normalized answer, see #939 (Sergey B
|
|
Kirpichev)
|
|
* Use mpf_log1p in acos_asin() helper (implementing Hull et al algorithm), see
|
|
#948 and #1036 (Sergey B Kirpichev)
|
|
* Fix kwargs passing in the nstr() for mpc, see #964 (David Walker)
|
|
* Fix exception type for int(inf), see #966 (Sergey B Kirpichev)
|
|
* Ensure exp, sin, tan, etc have a correct __name__ attribute, see #997
|
|
(Warren Weckesser)
|
|
* Matrix raise ValueError in case of negative dimensions, see #1004 (Ayush
|
|
Baranwal)
|
|
* Support lists in sinm() and cosm(), see #1003 (Ayush Baranwal)
|
|
* Properly handle nan's elliprj(), see #1038 (Sergey B Kirpichev)
|
|
* Raise ValueError for logm(0), see #1017 (Ayush Baranwal)
|
|
* Fix erf(z) with re(z) of large magnitude, see #1039 (Sergey B Kirpichev)
|
|
* Return nan's for polylog(s, nan) or polylog(s, nan+nanj),
|
|
see #1041 (Sergey B Kirpichev)
|
|
* Fix fp.isnormal() for subnormals, see #1042 (Sergey B Kirpichev)
|
|
|
|
Maintenance:
|
|
|
|
* Use codecov/coverage-action, see #674 (Sergey B Kirpichev)
|
|
* Run CI tests with pytest-xdist, see #685 (Sergey B Kirpichev)
|
|
* Add pyproject.toml, depend on flake518, see #684 (Sergey B Kirpichev)
|
|
* Port torture.py/extratest_zeta.py/extratest_gamma.py to the pytest
|
|
framework, see #687 (Sergey B Kirpichev)
|
|
* Create CITATION.bib, see #681 (Devharsh Trivedi)
|
|
* Avoid using star imports in tests and documentation, see #698 (Sergey B
|
|
Kirpichev)
|
|
* Fix some py2's remnants and remove old gmpy workarounds, see #699 (Sergey B
|
|
Kirpichev)
|
|
* Use math.isqrt in isqrt_python calculations, see #695 (Daiki Takahashi)
|
|
* Use gcd() and other bigint's functions from the backend, see #697 (Sergey B
|
|
Kirpichev)
|
|
* Drop legacy and redundant code, see #701 (Sergey B Kirpichev)
|
|
* Change FPContext to use more functions from the stdlib, see #692 (Sergey B
|
|
Kirpichev)
|
|
* Avoid dynamic method creation in _mpf, see #702 (Sergey B Kirpichev)
|
|
* Enable testing on CPython 3.12-dev, see #706 (Sergey B Kirpichev)
|
|
* Use bit_length() method instead of bitcount(), see #721 (Sergey B Kirpichev)
|
|
* Use lru_cache() in ifib() and eulernum(), isprime() alternatives from
|
|
backends, see #722 (Sergey B Kirpichev)
|
|
* Use setuptools_scm to update __version__, see #694 (Sergey B Kirpichev)
|
|
* Run tests on 3.13, see #759 (Sergey B Kirpichev)
|
|
* Do not build depend on pip and wheel, see #758 (Gonzalo Tornaría)
|
|
* Add CONTRIBUTING.rst, see #763 (Sergey B Kirpichev)
|
|
* Simplify ctx_mp_python.py, see #806 (Sergey B Kirpichev)
|
|
* Update gmpy2 deps, see #808 and #813 (Sergey B Kirpichev)
|
|
* Enable testing on 3.14, see #851 (Sergey B Kirpichev)
|
|
* Refactor Github Actions, see #905 (Sergey B Kirpichev)
|
|
* Build and publish wheel, see #913 (David Hotham)
|
|
* Use the intended setuptools_scm integration pattern, see #940 (Ronny
|
|
Pfannschmidt)
|
|
* Add backport action, see #1042 (Sergey B Kirpichev)
|
|
|
|
See the release milestone (1.4) for a complete list of issues and pull requests
|
|
involved in this release.
|
|
|
|
|
|
--1.3.0--
|
|
Released March 7, 2023
|
|
|
|
Security issues:
|
|
|
|
* Fixed ReDOS vulnerability in mpmathify() (CVE-2021-29063) (Vinzent Steinberg)
|
|
|
|
Features:
|
|
|
|
* Added quadsubdiv() for numerical integration with adaptive path splitting
|
|
(Fredrik Johansson)
|
|
* Added the Cohen algorithm for inverse Laplace transforms
|
|
(Guillermo Navas-Palencia)
|
|
* Some speedup of matrix multiplication (Fredrik Johansson)
|
|
* Optimizations to Carlson elliptic integrals (Paul Masson)
|
|
* Added signal functions (squarew(), trianglew(), sawtoothw(), unit_triangle()
|
|
sigmoidw()) (Nike Dattani, Deyan Mihaylov, Tina Yu)
|
|
|
|
Bug fixes:
|
|
|
|
* Correct mpf initialization from tuple for finf and fninf (Sergey B Kirpichev)
|
|
* Support QR decomposition for matrices of width 0 and 1 (Clemens Hofreither)
|
|
* Fixed some cases where elliprj() gave inaccurate results (Fredrik Johansson)
|
|
* Fixed cases where digamma() hangs for complex input (Fredrik Johansson)
|
|
* Fixed cases of polylog() with integer-valued parameter with complex type
|
|
(Fredrik Johansson)
|
|
* Fixed fp.nsum() with Euler-Maclaurin algorithm (Fredrik Johansson)
|
|
|
|
Maintenance:
|
|
|
|
* Dropped support for Python 3.4 (Sergey B Kirpichev)
|
|
* Documentation cleanup (Sergey B Kirpichev)
|
|
* Removed obsolete files (Sergey B Kirpichev)
|
|
* Added options to runtests.py to skip tests and exit on failure
|
|
(Jonathan Warner)
|
|
|
|
|
|
--1.2.0--
|
|
Released February 1, 2021
|
|
|
|
Features and optimizations:
|
|
|
|
* Support @ operator for matrix multiplication (Max Gaukler)
|
|
* Add eta() implementing the Dedekind eta function
|
|
* Optimized the python_trailing function (adhoc-king)
|
|
* Implement unary plus for matrices (Max Gaukler)
|
|
* Improved calculation of gram_index (p15-git-acc)
|
|
|
|
Compatibility:
|
|
|
|
* Enable sage backend by default only if SAGE_ROOT is set (Pauli Virtanen)
|
|
* Fix syntax warnings on CPython 3.8 (Sergey B Kirpichev)
|
|
* Changed version requirements to Python 2.7 and 3.4 or later
|
|
(Sergey B Kirpichev)
|
|
* Improvements to the setup and test code (Sergey B Kirpichev)
|
|
* Fix sys.version comparisons for compatibility with Python 3.10 (Jakub Wilk)
|
|
* Fixes to Python2/3 compatibility for printing (Christian Clauss)
|
|
|
|
Bug fixes:
|
|
|
|
* Fix a possible division by zero in shanks() (Pascal Hebbeker)
|
|
* Fixed indexing errors in deHoog, Knight & Stokes inverse laplace
|
|
transform algorithm (Kris Kuhlman)
|
|
* Corrected branch cuts of the elliprj() function in some cases
|
|
* Fix initialization of iv.matrix from non-interval matrix (Max Gaukler)
|
|
* Preserve function signatures in PrecisionManager (Viet Tran)
|
|
* Implemented float and complex conversions for ivmpf
|
|
(Jonathan Warner)
|
|
* Fixed issue with scalar-matrix multiplication for interval matrices
|
|
(Jonathan Warner)
|
|
* Fix estimation of quadrature error with multiple subintervals (Tom Minka)
|
|
* Fixed a problem with the defun decorators (Sergey B Kirpichev)
|
|
* Fix eigenvalue sorting by absolute value (Georg Ostrovski)
|
|
|
|
Cleanup:
|
|
|
|
* Documentation corrections (Paul Masson, S.Y. Lee)
|
|
* Remove inaccessible logic in fsum/fdot (Sergey B Kirpichev)
|
|
* Remove broken force_type option for matrix constructor (Max Gaukler)
|
|
* Fix text of the BSD license in LICENSE (Sergey B Kirpichev)
|
|
* Minor code cleanup (Frédéric Chapoton)
|
|
* Removed old, unused code
|
|
|
|
|
|
--1.1.0--
|
|
Released December 11, 2018
|
|
|
|
Bugs:
|
|
* Fixed severe bug in householder() for complex matrices
|
|
(Michael Kagalenko)
|
|
* Fixed frequently-reported bug where findroot() mysteriously raised
|
|
UnboundLocalError (Sergey B Kirpichev)
|
|
* Corrected rounding in binary-to-decimal conversion above 500 digits
|
|
* Fixed minor loss of accuracy affecting rf(), ff(), binomial(), beta()
|
|
* Fixed incorrect computation of the Hurwitz zeta function in some cases
|
|
* Fixed accuracy of digamma function near 0
|
|
* Fixed RuntimeError in qfac() in Python 3.7 caused by raising
|
|
StopIteration (Zbigniew Jędrzejewski-Szmek)
|
|
* Fix to allow NumPy arrays in fdot() (Nico Schlömer)
|
|
|
|
Features and improvements:
|
|
* Added more automatic conversions from Fraction, Decimal, NumPy types
|
|
(Jonathan Warner)
|
|
* Support creating mpf from a long literal (ylemkimon)
|
|
* Implemented log1p()
|
|
* Slight speedup of eig()
|
|
* Implement polylog() for general complex s and z by using Hurwitz zeta
|
|
algorithm as a fallback
|
|
|
|
Library:
|
|
* Test more CPython and PyPy versions (Sergey B Kirpichev, Aaron Meurer)
|
|
* Drop support for Python 2.6 and 3.2 (Sergey B Kirpichev)
|
|
* Use py.test for test code; lots of code cleanup (Sergey B Kirpichev)
|
|
* Corrections to the documentation (Paul Masson, Connor Behan,
|
|
Warren Weckesser, Aaron Meurer)
|
|
|
|
--1.0.0--
|
|
Released September 27, 2017
|
|
|
|
* Bumped to major version number for 10 year anniversary
|
|
* Added module for inverse Laplace transforms, including the top level
|
|
function invertlaplace() as well as several different algorithms
|
|
(Talbot, Gaver-Stehfest and de Hoog) implemented in
|
|
mpmath.calculus.inverselaplace (Kris Kuhlman)
|
|
* Fixed bugs in elliprg() giving incorrect values for certain input
|
|
* Fixed wrong degree 1 nodes for Gaussian quadrature
|
|
* Made make acot(0) and acoth(0) return a finite result
|
|
* Fixed sieved zeta sum not being used in Python 3, and added cutoff
|
|
for sieved zeta sum on 32-bit systems when too much memory would be used
|
|
* Fixed zeta(0,0.5) to return correct value instead of raising
|
|
NoConvergence exception
|
|
* Added detection of exact zeros in gammainc(), in particular fixing
|
|
NoConvergence error for gammainc(3,-1+1j)
|
|
* Fixed wrong values from besseli() due to improper internal precision
|
|
* Fixed bessely(0,1j) to return complex nan instead of raising NameError
|
|
(Paul Masson)
|
|
* Changed float() and complex() applied to an mpf or mpc to use rounding
|
|
to nearest (or the context rounding mode) instead truncating
|
|
* Fix imaginary part of gammainc(n,x), n negative odd int, x < 0
|
|
* Added alternative "phase" color scheme to cplot()
|
|
* Better error message for int(inf) or int(nan) (Aaron Meurer)
|
|
* Fixed polyroots() with error=True
|
|
* Added support to pass optional initial values to polyroots()
|
|
(Michael Kagalenko)
|
|
* Rewrote the Python major version selection to make it work if something
|
|
else has redefined xrange (Arne Brys)
|
|
* Switched documentation formula rendering to MathJax (Sergey B Kirpichev)
|
|
* Fixed documentation TeX build (Sergey B Kirpichev)
|
|
* Added PEP8 conformity testing (Sergey B Kirpichev)
|
|
* Various fixes for the test code and test infrastructure on different
|
|
platforms and Python versions (Sergey B Kirpichev)
|
|
* Fixed module paths in setup.py (Aaron Meurer)
|
|
* Documented more options for methods such as nstr() and hyper()
|
|
* Miscellaneous corrections to the documentation (various)
|
|
|
|
--0.19--
|
|
Released June 10, 2014
|
|
|
|
* Moved issue tracking to github and the main website to mpmath.org.
|
|
Several URLs and issue numbers were updated in the documentation
|
|
(Sergey B Kirpichev)
|
|
* Enabled automatic testing with Travis CI (Sergey B Kirpichev)
|
|
* Fixed many doctest issues (Sergey B Kirpichev)
|
|
* Converted line endings to LF (Ondrej Certik)
|
|
* Made polyroots() more robust (Ondrej Certik)
|
|
|
|
--0.18--
|
|
Released December 31, 2013
|
|
|
|
Linear algebra:
|
|
* added qr() for matrix QR factorization (contributed by Ken Allen)
|
|
* added functions eigsy(), eighe(), eig() to compute matrix
|
|
eigenvalues (contributed by Timo Hartmann)
|
|
* added functions svd(), svd_r(), svd_c() for singular value
|
|
decomposition of matrices (contributed by Timo Hartmann)
|
|
* added calculation of Gaussian quadrature rules for various weight
|
|
functions (contributed by Timo Hartmann)
|
|
* improved precision selection in exp_pade() (contributed by
|
|
Mario Pernici)
|
|
|
|
Special functions:
|
|
* fixed ellippi() to return an inf instead of raising an exception
|
|
* fixed a crash in zeta() with huge arguments
|
|
* added functions for computing Stirling numbers
|
|
(stirling1(), stirling2())
|
|
* improved the computation of zeros of zeta at high precision
|
|
(contributed by Juan Arias de Reyna)
|
|
* fixed zeta(-x) raising an exception for tiny x
|
|
* recognize when lerchphi() can call zeta() or polylog(),
|
|
handling those cases faster
|
|
|
|
Compatibility:
|
|
* fixed gmpy2 compatibility issues (contributed by Case Van Horsen)
|
|
* better solutions for python 2/3 compatibility,
|
|
using Benjamin Peterson's six.py
|
|
* fixes to allow mpmath to run in non-sage mode when sage is available
|
|
* support abstract base classes (contributed by Stefan Krastanov)
|
|
* use new-style classes to improve pypy performance
|
|
|
|
Other:
|
|
* added Levin, Sidi-S and Cohen/Villegas/Zagier series
|
|
transformations (contributed by Timo Hartmann)
|
|
* added isfinite() utility function
|
|
* fixed a problem with bisection root-finding
|
|
* fixed several documentation errors
|
|
* corrected number of coefficients returned by diffs() with
|
|
method='quad'
|
|
* fixed repr(constant) being slow at high precision
|
|
* made intervals hashable
|
|
|
|
--0.17--
|
|
Released February 1, 2011
|
|
|
|
Compatibility:
|
|
|
|
* Python 3 is now supported
|
|
* Dropped Python 2.4 compatibility
|
|
* Fixed Python 2.5 compatibility in matrix slicing code
|
|
* Implemented Python 3.2-compatible hashing, making mpmath numbers
|
|
hash compatible with extremely large integers and with fractions
|
|
in Python versions >= 3.2 (contributed by Case Vanhorsen)
|
|
|
|
Special functions:
|
|
|
|
* Implemented the von Mangoldt function (mangoldt())
|
|
* Implemented the "secondary zeta function" (secondzeta()) (contributed
|
|
by Juan Arias de Reyna).
|
|
* Implemented zeta zero counting (nzeros()) and the Backlund S function
|
|
(backlunds()) (contributed by Juan Arias de Reyna)
|
|
* Implemented derivatives of order 1-4 for siegelz() and siegeltheta()
|
|
(contributed by Juan Arias de Reyna)
|
|
* Improved Euler-Maclaurin summation for zeta() to give more accurate
|
|
results in the right half-plane when the reflection formula
|
|
cannot be used
|
|
* Implemented the Lerch transcendent (lerchphi())
|
|
* Fixed polygamma function to return a complex NaN at complex
|
|
infinity or NaN, instead of raising an unrelated exception.
|
|
|
|
|
|
--0.16--
|
|
Released September 24, 2010
|
|
|
|
Backends and distribution:
|
|
|
|
* Added Sage hooks for Cython versions of exp, ln, cos, sin,
|
|
hypergeometric series, and some related functions
|
|
* Fixed imports for gmpy2 compatibility (contributed by Case Van Horsen)
|
|
* Removed documentation from main mpmath package to save space (a separate
|
|
tar.gz file is now provided for the documentation sources)
|
|
* Fixed matplotlib version detection
|
|
* Converted files to Unix line endings
|
|
|
|
Special functions:
|
|
|
|
* Started adding plots of special functions to the documentation
|
|
* Added Anger and Weber functions (angerj(), webere())
|
|
* Added Lommel functions (lommels1(), lommels2())
|
|
* Added interval versions of gamma(), loggamma(), rgamma() and
|
|
factorial()
|
|
* Rewritten Airy functions to improve speed and accuracy
|
|
* Support for arbitrary-order derivatives of airyai(), airybi()
|
|
* Added Airy function zeros (airyaizero(), airybizero())
|
|
* Added Scorer functions (scorergi(), scorerhi())
|
|
* Added computation of Bessel function zeros and Bessel function
|
|
derivative zeros (besseljzero(), besselyzero())
|
|
* Fixed besselj(mpc(n), z)
|
|
* Rewritten lambertw() to fix various subtle bugs and robustly handle
|
|
numerical difficulties near branch cuts and branch points.
|
|
* Fixed fp.lambertw() to behave the same on branch cuts on systems with
|
|
and without signed-zero floats
|
|
* Added Carlson symmetric incomplete elliptic integrals
|
|
(elliprf(), elliprc(), elliprj(), elliprd(), elliprg())
|
|
* Added Legendre incomplete elliptic integrals (ellipf(), ellippi(),
|
|
ellipe() with two arguments)
|
|
* Implemented Parabolic cylinder functions (pcfd(), pcfu(), pcfv(),
|
|
pcfw())
|
|
* Implemented Euler-Maclaurin summation for hypergeometric functions
|
|
of order (p,p-1) to support evaluation with z close to 1 in remaining cases
|
|
* Fixed a bug in hypergeometric series summation, causing occasional
|
|
inaccurate results and incorrect detection of zeros
|
|
* Fixed qfrom(m=...)
|
|
|
|
Calculus:
|
|
|
|
* Implemented generators diffs_exp(), diffs_prod() for composing
|
|
derivatives
|
|
* Implemented Abel-Plana summation for infinite series (sumap())
|
|
|
|
Basic arithmetic and functions:
|
|
|
|
* Implemented matrix slice indexing, supporting submatrix
|
|
extraction and assignment (contributed by Ioannis Tziakos)
|
|
* Added missing constant fp.glaisher
|
|
* Fixed a bug preventing internal rational numbers from being
|
|
hashable
|
|
* Fixed bug in isnpint()
|
|
* Fixed a bug in cos_sin() for pure imaginary argument
|
|
* Slightly improved performance for elementary functions of pure
|
|
real or pure imaginary mpc inputs
|
|
* Fixed plot() with real-valued mpc instances
|
|
* Fixed cplot() to work with endpoints of other type than float/int
|
|
|
|
|
|
--0.15--
|
|
Released June 6, 2010
|
|
|
|
Basic transcendental functions:
|
|
|
|
* Reimplemented all elementary functions except log, reducing
|
|
overhead and giving asymptotic speedups at high precision
|
|
* Reimplemented gamma() and loggamma(), improving speed and
|
|
fixing accuracy in corner cases
|
|
* Added rgamma() (reciprocal gamma function)
|
|
* Added a stress test suite for the gamma function
|
|
* Provided top-level functions cos_sin() and cospi_sinpi() for fast
|
|
simultaneous computation
|
|
|
|
Riemann zeta function:
|
|
|
|
* New zetazeros() implementation, supporting arbitrarily large indices
|
|
(contributed by Juan Arias de Reyna)
|
|
* Tuned algorithm selection in zeta() for complex arguments
|
|
(contributed by Juan Arias de Reyna)
|
|
* Accelerated computation of zeta function series using sieving
|
|
|
|
Special functions:
|
|
|
|
* Added qfrom(), qbarfrom(), mfrom(), kfrom(), taufrom() for elliptic
|
|
argument conversion
|
|
* Merged jsn(), jcn(), jdn() -> ellipfun() and generalized it to compute
|
|
all 12 Jacobi elliptic functions
|
|
* Implemented the Klein j-invariant (kleinj())
|
|
* Implemented the q-Pochhammer symbol (qp())
|
|
* Implemented q-factorial (qfac()) and q--gamma (qgamma())
|
|
* Implemented q-hypergeometric series (qhyper())
|
|
* Implemented bilateral hypergeometric series (bihyper())
|
|
* Implemented Appell 2D hypergeometric series F2-F4 (appellf2()-appellf4())
|
|
* Implemented generalized 2D hypergeometric series (hyper2d())
|
|
* Fixed gammainc() for integer-valued complex argument (contributed by
|
|
Juan Arias de Reyna)
|
|
* Fixed asymptotic expansion of hyp1f1() (contributed by Juan Arias de Reyna)
|
|
|
|
Numerical calculus:
|
|
|
|
* Added support for multidimensional series in nsum()
|
|
* Made nprod() faster by default by extrapolating directly instead of
|
|
calling nsum()
|
|
* Changed some options for diff()/diffs()
|
|
* Made taylor() chop tiny coefficients by default
|
|
* Added support for partial derivatives in diff()
|
|
|
|
Interval arithmetic:
|
|
|
|
* All interval arithmetic functionality moved to a separate context
|
|
namespace (iv)
|
|
* Preliminary support for complex intervals (iv.mpc)
|
|
* Fixed interval cos/sin to support intervals overlapping zeros/extreme points
|
|
* Implemented interval atan2
|
|
* Implemented exp/log/cos/sin for complex intervals
|
|
* Some other interface changes to interval code
|
|
|
|
Utility functions:
|
|
|
|
* Made chop() use relative rather than absolute tolerance for
|
|
real/imaginary parts
|
|
* Optimized floor(), ceil(), isinf(), isnan(), isint()
|
|
* Implemented nint(), frac(), isnormal()
|
|
* Fixed and documented semantics for isinf(), isin(), isnan()
|
|
* Added utility functions autoprec(), maxcalls(), memoize()
|
|
|
|
Miscellaneous tweaks and fixes:
|
|
|
|
* Support complex conjugation in fdot()
|
|
* Added support for Cholesky decomposition of complex matrices
|
|
* Fixed a small precision bug in linear algebra functions
|
|
* Suppress NoConvergence exception when plotting
|
|
* Removed some dirty code to improve PyPy compatibility
|
|
* Fixed plotting to work with mpmath numbers in the interval specification
|
|
* Fixed fp arithmetic on systems where math.log and math.sqrt return NaN
|
|
instead of raising an exception
|
|
* Fixed fp.conj for Python 2.4 and 2.5
|
|
* Fixed quadrature to work with reversed infinite intervals such as [0,-inf]
|
|
* Renamed modf() -> fmod() for consistency
|
|
|
|
--0.14--
|
|
Released February 5, 2010
|
|
|
|
General changes:
|
|
|
|
* Fully separated the code into "low-level" and "high-level", permitting the
|
|
use of alternative contexts (the mpmath.mp object provides the default
|
|
implementation)
|
|
* Implemented a context for fast double-precision arithmetic using Python
|
|
types (mpmath.fp)
|
|
* Implemented hooks for importing a faster version of mp arithmetic from Sage
|
|
* Implemented optimized fp versions of certain functions (including erf, erfc,
|
|
gamma, digamma, ei, e1)
|
|
* Renamed and reorganized various internal modules and methods (including
|
|
merging low-level modules into mpmath.libmp). This should not affect most
|
|
external code using top-level imports.
|
|
|
|
Plotting:
|
|
|
|
* Implemented splot() for 3D surface plots (contributed by Jorn Baayen)
|
|
* Permit calling plot functions with custom axes (contributed by Jorn Baayen)
|
|
|
|
Matrices:
|
|
|
|
* Fixed lu_solve for overdetermined systems (contributed by Vinzent Steinberg)
|
|
* Added conjugate matrix transpose (contributed by Vinzent Steinberg)
|
|
* Implemented matrix functions (expm, cosm, sinm, sqrtm, logm, powm)
|
|
|
|
Miscellaneous:
|
|
|
|
* Prettier printing of numbers with leading zeros at small precisions
|
|
* Made nstr pass on kwargs, permitting more formatting options
|
|
* Fixed wrong directed rounding of addition of numbers with large magnitude
|
|
differences
|
|
* Fixed several docstring typos (contributed by Chris Smith)
|
|
* Fixed a bug that prevented caching of quadrature nodes to work optimally.
|
|
|
|
Special functions:
|
|
|
|
* Implemented fast evaluation for large imaginary heights of the Riemann zeta
|
|
function, Z function and derived functions using the Riemann-Siegel
|
|
(contributed by Juan Arias de Reyna)
|
|
* Unified the zeta() and hurwitz() functions, automatically selecting a fast
|
|
algorithm
|
|
* Improved altzeta() to fall back to zeta() for large arguments
|
|
* Fixed accuracy of zeta(s) for s ~= 1
|
|
* Implemented exact evaluation of Euler numbers (contributed by Juan Arias
|
|
de Reyna)
|
|
* Implemented numerical evaluation of Euler numbers and Euler polynomials
|
|
(eulernum(), eulerpoly())
|
|
* Fixed bernpoly() and eulerpoly() to compute accurate values for large
|
|
parameters
|
|
* Fixed accuracy problems for hypergeometric functions with large parameters
|
|
* Faster evaluation of hypergeometric series using on-the-fly code generation
|
|
* Optimized hypercomb to detect certain zero terms symbolically
|
|
* Removed the djtheta function (jtheta() accepts a derivative parameter)
|
|
* Implemented li(x, offset=True) to compute the offset logarithmic integral
|
|
* Fixed wrong branch in Lambert W function for certain complex inputs
|
|
* Implemented the reflection formula for the Barnes G-function,
|
|
superfactorials, hyperfactorials, permitting large arguments in the left
|
|
half-plane
|
|
* Implemented analytic continuation to |z| >= 1 for hypergeometric functions
|
|
pFq with p=q+1; added hyp3f2()
|
|
* Implemented Borel summation of divergent pFq functions with p > q+1
|
|
* Implemented automatic degree reduction of hypergeometric functions with
|
|
repeated parameters
|
|
* Added convenience functions expj(), expjpi()
|
|
* Use Mathematica's convention for the continuation of the Meijer G-function
|
|
* Added phase(), polar(), rect() functions for compatibility with the
|
|
Python 2.6 cmath module
|
|
* Implemented spherical harmonics (spherharm())
|
|
* Optimized ci(), si(), chi(), shi() for complex arguments by evaluating
|
|
them in terms of ei()
|
|
* Optimized hyp2f1 for z ~= -1
|
|
|
|
--0.13--
|
|
Released August 13, 2009
|
|
|
|
New special functions:
|
|
|
|
* The generalized exponential integral E_n (expint(), e1() for E_1)
|
|
* The generalized incomplete beta function (betainc())
|
|
* Whittaker functions (whitm(), whitw())
|
|
* Struve functions (struveh(), struvel())
|
|
* Kelvin functions (ber(), bei(), ker(), kei())
|
|
* Cyclotomic polynomials (cyclotomic())
|
|
* The Meijer G-function (meijerg())
|
|
* Clausen functions (clsin(), clcos())
|
|
* The Appell F1 hypergeometric function of two variables (appellf1())
|
|
* The Hurwitz zeta function, with nth order derivatives (hurwitz())
|
|
* Dirichlet L-series (dirichlet())
|
|
* Coulomb wave functions (coulombf(), coulombg(), coulombc())
|
|
* Associated Legendre functions of 1st and 2nd kind (legenp(), legenq())
|
|
* Hermite polynomials (hermite())
|
|
* Gegenbauer polynomials (gegenbauer())
|
|
* Associated Laguerre polynomials (laguerre())
|
|
* Hypergeometric functions hyp1f2(), hyp2f2(), hyp2f3(), hyp2f0(), hyperu()
|
|
|
|
Evaluation of hypergeometric functions:
|
|
|
|
* Added the function hypercomb() for evaluating expressions containing
|
|
hypergeometric series, with automatic handling of limits
|
|
* The available hypergeometric series (of orders up to and including 2F3)
|
|
implement asymptotic expansions with respect to the last argument z, allowing
|
|
fast and accurate evaluation anywhere in the complex plane. A massive number
|
|
of functions, including Bessel functions, error functions, etc., have been
|
|
updated to take advantage of this to support fast and accurate evaluation
|
|
anywhere in the complex plane.
|
|
* Fixed hyp2f1 to handle z close to and on the unit circle (supporting
|
|
evaluation anywhere in the complex plane)
|
|
* hyper() handles the 0F0 and 1F0 cases exactly
|
|
* hyper() eventually raises NoConvergence instead of getting stuck in
|
|
an infinite loop if given a divergent or extremely slowly convergent series
|
|
|
|
Other improvements and bug fixes to special functions:
|
|
|
|
* gammainc is much faster for large arguments and avoids catastrophic
|
|
cancellation
|
|
* Implemented specialized code for ei(x), e1(x), expint(n,x) and gammainc(n,x)
|
|
for small integers n, making evaluation much faster
|
|
* Extended the domain of polylog
|
|
* Fixed accuracy for asin(x) near x = 1
|
|
* Fast evaluation of Bernoulli polynomials for large z
|
|
* Fixed Jacobi polynomials to handle some poles
|
|
* Some Bessel functions support computing nth order derivatives
|
|
* A set of "torture tests" for special functions is available as
|
|
tests/torture.py
|
|
|
|
Other:
|
|
* Implemented the differint() function for fractional differentiaton / iterated
|
|
integration
|
|
* Added functions fadd, fsub, fneg, fmul, fdiv for high-level arithmetic with
|
|
controllable precision and rounding
|
|
* Added the function mag() for quick order-of-magnitude estimates of numbers
|
|
* Implemented powm1() for accurate calculation of x^y-1
|
|
* Improved speed and accuracy for raising a pure imaginary number to
|
|
an integer power
|
|
* nthroot() renamed to root(); root() optionally computes any of
|
|
the non-principal roots of a number
|
|
* Implemented unitroots() for generating all (primitive) roots of unity
|
|
* Added the mp.pretty option for nicer repr output
|
|
|
|
--0.12--
|
|
Released June 9, 2009
|
|
|
|
General
|
|
* It is now possible to create multiple context objects and use context-local
|
|
methods instead of global state/functions (e.g. mp2=mp.clone(); mp2.dps=50;
|
|
mp2.cos(3)). Not all functions have been converted to context methods, and
|
|
there are some bugs, so this feature is currently experimental.
|
|
* If mpmath is installed in Sage 4.0 or later, mpmath will now use sage.Integer
|
|
instead of Python long internally.
|
|
* Removed instances of old-style integer division from the codebase.
|
|
* runtests.py can be run with -coverage to generate coverage statistics.
|
|
|
|
Types and basic arithmetic
|
|
|
|
* Fixed comparison with -inf.
|
|
* Changed repr format of the mpi interval type to make eval(repr(x)) == x.
|
|
* Improved printing of intervals, with configurable output format (contributed
|
|
by Vinzent Steinberg based on code by Don Peterson).
|
|
* Intervals supported by mpmathify() and nstr() (contributed by Vinzent
|
|
Steinberg).
|
|
* mpc is now hashable.
|
|
* Added more formatting options to the internal function to_str.
|
|
* Faster pure-Python square root.
|
|
* Fix trailing whitespace giving wrong values in str->mpf conversion.
|
|
|
|
Calculus
|
|
|
|
* Fixed nsum() with Euler-Maclaurin summation which would previously
|
|
ignore the starting index and sum from n=1.
|
|
* Implemented Newton's method for findroot() (contributed by Vinzent
|
|
Steinberg).
|
|
|
|
Linear algebra
|
|
|
|
* Fixed LU_decomp() to recognize singular matrices (contributed by Jorn Baayen).
|
|
* The various norm functions were replaced by the generic vector norm
|
|
function norm(x,p) and the generic matrix norm function mnorm(x,p).
|
|
|
|
Special functions:
|
|
|
|
* Some internal caches were changed to always slightly overallocate
|
|
precision. This fixes worst-case behavior where previously the cached
|
|
value had to be recomputed on every function call.
|
|
* Fixed log(tiny number) returning nonsense at high precision.
|
|
* Fixed gamma() and derivative functions such as binomial() returning
|
|
wrong results at integer inputs being divisible by a large power of 2.
|
|
* Fixed asin() not to raise an exception at high precision (contributed
|
|
by Vinzent Steinberg).
|
|
* Optimized the AGM code for the natural logarithm, making the previously
|
|
used Newton method at intermediate precisions obsolete.
|
|
* The arithmetic-geometric mean function agm() is now an order of magnitude
|
|
faster at low precision.
|
|
* Faster implementations of ellipk() and ellipe().
|
|
* Analytic continuation of ellipe() to |x| >= 1 implemented.
|
|
* Implemented the log gamma function (loggamma()) with correct branch
|
|
cuts (slow, placeholder implementation).
|
|
* Fixed branch cuts of hyperfac().
|
|
* Implemented the Riemann-Siegel Z-function (siegelz()).
|
|
* Implemented the Riemann-Siegel theta function (siegeltheta()).
|
|
* Implemented calculation of Gram points (grampoint()).
|
|
* Implemented calculation of Riemann zeta function zeros (zetazero()).
|
|
* Implemented the prime counting function: a slow, exact version (primepi()).
|
|
and a fast approximate version (primepi2()) that gives a bounding interval.
|
|
* Implemented the Riemann R prime counting function (riemannr()).
|
|
* Implemented Bell numbers and polynomials (bell()).
|
|
* Implemented the expm1() function.
|
|
* Implemented the 'polyexponential function' (polyexp()).
|
|
* Implemented the twin prime constant (twinprime) and Mertens' constant
|
|
(mertens).
|
|
* Implemented the prime zeta function (primezeta()).
|
|
|
|
|
|
--0.11--
|
|
Released January 26, 2009
|
|
|
|
General:
|
|
|
|
* Most of the documentation is now generated from docstrings
|
|
using Sphinx' autodoc feature, and proper LaTeX is used
|
|
for mathematical formulas. A large amount of new documentation
|
|
has been written.
|
|
* Improved gmpy backend. Using gmpy-1.04 gives a ~30% unit tests
|
|
speedup over 1.03, with speedups in the range of 2-3x for
|
|
specific operations (contributed by Case van Horsen and
|
|
Mario Pernici).
|
|
* Mpmath imports slightly faster due to not trying to
|
|
load the 'random' library
|
|
|
|
Numerical calculus, etc:
|
|
|
|
* Implemented a fast high-precision ODE solver (to replace the slow
|
|
and low-accuracy RK4 algorithm) (odefun())
|
|
* Created an intelligent function nsum() to replace sumrich/sumsh
|
|
* Implemented nprod() for computing infinite products
|
|
* Rewrote limit() to use the same adaptive extrapolation algorithm
|
|
as nsum()
|
|
* Multidimensional nonlinear solving with Newton's method
|
|
implemented in findroot() (contributed by Vinzent Steinberg)
|
|
* Simplified the implementation and interface of sumem()
|
|
* Reimplemented Shanks transformation for nsum using Wynn's epsilon
|
|
algorithm (shanks())
|
|
* Reimplemented Richardson extrapolation slightly more simply and
|
|
efficiently (richardson())
|
|
* Prevent shanks() from exiting prematurely by adding
|
|
random noise to zeros
|
|
* Removed the obsolete secant() function (see findroot())
|
|
* Implemented high-order derivatives (diff(), diffs())
|
|
* Implemented calculation of Taylor series (taylor())
|
|
* Implemented calculation of Fourier series (fourier(), fourierval())
|
|
* Implemented Pade approximation (pade()) (contributed by
|
|
Mario Pernici)
|
|
* Better cancel condition for findroot() (contributed by
|
|
Vinzent Steinberg)
|
|
* Some refactoring of numerical integration code
|
|
* Fix erroneous nodes for 0-th order Gauss-Legendre quadrature,
|
|
which was causing unnecessary slowness
|
|
* Quadrature nodes are cached for arbitrary intervals, giving a
|
|
30% speedup for repeated integrations
|
|
* Unified interface and added more options for identify(), pslq(), findpoly()
|
|
|
|
New special functions:
|
|
|
|
* Implemented polylogarithms (polylog())
|
|
* Implemented Bernoulli polynomials (bernpoly())
|
|
* Implemented the Barnes G-function (barnesg())
|
|
* Implemented double factorials (fac2())
|
|
* Implemented superfactorials (superfac())
|
|
* Implemented hyperfactorials (hyperfac())
|
|
* Replaced lower_gamma and upper_gamma with a more versatile
|
|
function gammainc() for computing the generalized (and optionally
|
|
regularized) incomplete gamma function
|
|
* Implemented sinc() and sincpi()
|
|
* Implemented Fibonacci numbers (fib())
|
|
* Implemented the Dirichlet eta function (altzeta())
|
|
* Implemented the inverse error function (erfinv())
|
|
* Jacobi theta functions and elliptic functions were essentially
|
|
rewritten from scratch, making them much faster and more
|
|
general. Renamed Jacobi theta functions: jacobi_theta -> jtheta,
|
|
etc. (contributed by Mario Pernici)
|
|
* Implemented derivatives of jtheta (djtheta) (contributed by
|
|
Mario Pernici)
|
|
* Implemented Bessel Y, I, K functions (bessely, besseli,
|
|
besselk; Bessel J functions were also renamed to besselj)
|
|
also renamed)
|
|
* Generalized Stieltjes constants can now be computed,
|
|
with stieltjes(n,a)
|
|
* Implemented Hankel functions (hankel1, hankel2)
|
|
|
|
Speed improvements and bugfixes to special functions:
|
|
* Fast logarithm at very high precision using the formula by
|
|
Sasaki and Kanada (contributed by Mario Pernici)
|
|
* Slightly faster logarithm at low precision (contributed by
|
|
Mario Pernici)
|
|
* Faster exponential function at high precision, using
|
|
Newton's method (contributed by Mario Pernici)
|
|
* Faster computation of ln2 and ln10 by means of binary splitting
|
|
(contributed by Mario Pernici)
|
|
* Fixed accuracy problems in sinpi() and cospi()
|
|
* Correct evaluation of beta() at limits
|
|
* Much faster evaluation of stieltjes(n), using an improved integral
|
|
formula
|
|
* Fixed bernoulli() being inaccurate for large n and low precision,
|
|
and being needlessly slow for small n and huge precision
|
|
* Fixed accuracy of zeta(s) for large negative re(s)
|
|
* Fixed accuracy problems for asinh, atanh and tanh
|
|
* Fixed accuracy of airyai() for large x.real
|
|
* Fixed bug in nthroot() for very large arguments (contributed by
|
|
Mario Pernici)
|
|
* Fixed accuracy of log(x) for complex |x| ~= 1
|
|
* Fixed accuracy of exp(n), n a huge integer and prec >= 600
|
|
* Slightly faster hypergeometric functions with rational parameters
|
|
(contributed by Mario Pernici)
|
|
* Faster and more accurate calculation of ci(x), si(x)
|
|
* Faster and more accurate calculation of ei(x) for large x,
|
|
using an asymptotic expansion (contributed by Mario Pernici)
|
|
* Fixed accuracy bugs in theta functions (contributed by
|
|
Mario Pernici)
|
|
* The Lambert W function returns more appropriate values at infinities
|
|
|
|
Arithmetic and basic interface:
|
|
* Square roots are now rounded correctly
|
|
* Made float(huge) -> inf and float(1/huge) -> 0 instead of
|
|
raising OverflowError
|
|
* Renamed convert_lossless -> mpmathify
|
|
* mpmathify() accepts strings representing fractions or complex
|
|
numbers (contributed by Vinzent Steinberg)
|
|
* Fixed a bug in interval multiplication giving wrong signs
|
|
* Added monitor() to monitor function evaluation
|
|
* Implemented a chop() utility function for deletion of numerical noise
|
|
* Added re(), im(), conj(), fabs(), mpf.conjugate()
|
|
* Fixed the != operator for intervals
|
|
* Added functions fsum, fprod, fdot for efficient computation of
|
|
sums, products and dot products of lists of mpf:s or mpc:s
|
|
|
|
Matrices:
|
|
|
|
* Generation of Hilbert matrices (hilbert()) (contributed by
|
|
Vinzent Steinberg)
|
|
* Added lu_solve_mat() to solve a*x=b where a and b are matrices (contributed
|
|
by Mario Pernici)
|
|
* Implemented computation of matrix exponentials (exp_pade()) (contributed
|
|
by Mario Pernici)
|
|
* Prettier repr of complex matrices (contributed by Vinzent Steinberg)
|
|
* Speedups by using fdot and fsum (contributed by Vinzent Steinberg)
|
|
|
|
--0.10--
|
|
Released October 15, 2008
|
|
|
|
Interface / general:
|
|
* Mpmath now works with Python 2.6
|
|
* Implemented function plotting via 'plot' and 'cplot' (requires
|
|
matplotlib)
|
|
* Removed global rounding mode (always rounding to nearest by default)
|
|
* Instead added 'prec', 'dps', 'rounding' keyword arguments to
|
|
standard functions, for optional fine-grained control over precision
|
|
and rounding
|
|
* Implemented isinf, isnan, isint, utility functions
|
|
* A large number of internal functions were moved and/or renamed to
|
|
improve consistency. This particularly affects low-level mpf
|
|
functions (lib.fadd -> libmpf.mpf_add, etc).
|
|
* Syntax for some operations was changed (see details below)
|
|
* The test runner (runtests.py) was updated to support running
|
|
isolated tests and to allow a local import of mpmath
|
|
* Unit tests can now be run with import mpmath; mpmath.runtests()
|
|
* Implicit imports are no longer used internally in the main codebase.
|
|
(This will hopefully make the source easier to read, and can catch
|
|
installation problems more cleanly.)
|
|
|
|
Added linear algebra functions (contributed by Vinzent Steinberg):
|
|
* Provided a matrix class
|
|
* Computation of powers, inverses, determinants
|
|
* Linear system solving using LU, QR and Cholesky
|
|
* Vector and matrix norms
|
|
* Calculation of condition numbers
|
|
|
|
Improvements to interval arithmetic:
|
|
* Fixed rounding direction for negative numbers and related
|
|
spurious bugs
|
|
* Fix interval exponentiation (all cases should work now)
|
|
* Basic interval arithmetic is up to 10x faster
|
|
* sqrt, exp, log, sin, cos and a few other functions
|
|
accept interval arguments
|
|
* Intervals supported in matrices
|
|
|
|
Changes to root-finding code:
|
|
* secant renamed to findroot
|
|
* findroot was made more general; many useful alternative root-finding
|
|
algorithms were implemented (contributed by Vinzent Steinberg)
|
|
|
|
Improvements to special functions:
|
|
* Implemented polygamma functions
|
|
* Implemented harmonic numbers
|
|
* Implemented Stieltjes constants
|
|
* Made gamma more accurate for huge arguments and/or precision
|
|
* Made zeta more accurate in various cases
|
|
* Made zeta typically 2-5x faster
|
|
* Much more efficient computation of zeta for huge s (zeta(s) ~= 1)
|
|
* Optimized numerical calculation of Bernoulli numbers
|
|
* Fast exact calculation of huge Bernoulli numbers via zeta and the
|
|
von Staudt-Clausen theorem
|
|
* Using AGM to compute ellipk, which is much faster and works
|
|
in the entire complex plane
|
|
* Allow single-argument form agm(x) = agm(1,x)
|
|
* Faster and more accurate computation of erf
|
|
* Added fast and accurate implementation of erfc
|
|
* Normal probability functions npdf, ncdf
|
|
* Fixed directed rounding in corner cases for various functions
|
|
|
|
Improvements to numerical integration:
|
|
* Changed syntax for integration (quad(f, [a, b], options))
|
|
* Implemented Gauss-Legendre quadrature
|
|
* Direct support for triple integrals (quad(f, X, Y, Z))
|
|
* Interval can be a list of several points, to split integration
|
|
into subintervals
|
|
* Oscillatory quadrature uses Gauss-Legendre instead of tanh-sinh,
|
|
since this is typically faster
|
|
* Fixed minor rounding bug in tanh-sinh quadrature not giving
|
|
complete symmetry in the nodes
|
|
* Implemented quadrature rules in classes for improved extensibility
|
|
|
|
Various speed improvements:
|
|
* Up to 3x faster computation of log(x) at low precision, due to using
|
|
Taylor series with argument reduction and partial caching
|
|
* About 2x faster log(x) at very high precision due to more efficient
|
|
computation of exp in the Newton iteration
|
|
* Up to 10x faster computation of atan(x) at low to medium precision,
|
|
due to using Taylor series with argument reduction and partial caching
|
|
* Faster pickling due to using hex() instead of long()
|
|
* Optimized code for Khinchin's constant (2.5x faster at 1000 digits)
|
|
* Optimized code for Glaisher's constant (1.5x faster at 1000 digits)
|
|
* Faster algorithm for Euler's constant (10x faster at 10000 digits)
|
|
* Rewrote PSLQ to use fixed-point arithmetic, giving a ~7x speedup
|
|
in pslq, findpoly and identify
|
|
|
|
Miscellaneous bugfixes:
|
|
* Fixed nthroot for n = -1, 0, 1
|
|
* Fixed inf/2**n and nan/2**n returning zero
|
|
|
|
--0.9--
|
|
Released August 23, 2008
|
|
|
|
* gmpy mpzs are used instead of python ints when available, for
|
|
huge speedups at high precision (contributed by Case Van Horsen)
|
|
* using binary splitting to compute pi and e near-optimally
|
|
* mpmath includes __version__ information
|
|
* arange behaves more like range (contributed by Vinzent Steinberg)
|
|
* asymptotically faster trigonometric functions via Brent's trick
|
|
(contributed by Mario Pernici)
|
|
* asymptotically faster inverse trigonometric functions via Newton's
|
|
method (contributed by Mario Pernici)
|
|
* added Jacobi elliptic functions 1-4, sn, cn, dn (contributed by Mike
|
|
Taschuk)
|
|
* polyval, polyroots and related functions now use the same order
|
|
for coefficients as scipy and matlab (i.e. the reverse order of what
|
|
was used previously in mpmath)
|
|
* fixed polyroots for degree-0 polynomials (contributed by Nimish Telang)
|
|
* added convenience functions (log10, degrees, radians, frexp, modf, ln,
|
|
arg, sign)
|
|
* added fast cbrt and nthroot functions for computing nth roots
|
|
(contributed by (Mario Pernici)
|
|
* added various exponential integrals (ei, li, si, ci, shi, chi, erfi)
|
|
* added airy functions (airyai, airybi)
|
|
* more __op__ and __rop__ methods return NotImplemented where
|
|
appropriate
|
|
* external classes can define a special method _mpmath_ to interact
|
|
with mpmath numbers and functions
|
|
* fixed some corner cases in atan2
|
|
* faster rand()
|
|
|
|
--0.8--
|
|
Released April 20, 2008
|
|
|
|
New features:
|
|
* the full set of reciprocal trigonometric and hyperbolic functions
|
|
and their inverses (cotangent, secant, etc) is available
|
|
* oscillatory quadrature algorithm
|
|
* the PSLQ algorithm and constant recognition functions
|
|
* Richardson and Shanks transformations for computing limits and series
|
|
* Euler-Maclaurin summation of series
|
|
* basic ODE solvers (contributed by Ondrej Certik)
|
|
* the Lambert W function
|
|
* arithmetic-geometric mean function
|
|
* generic hypergeometric series and some special hypergeometric
|
|
functions (elliptic integrals, orthogonal polynomials)
|
|
* several more mathematical constants
|
|
* fast sequential computation of integer logarithms and Bernoulli
|
|
numbers
|
|
* Bessel function jv works for complex arguments and noninteger v
|
|
* support for trapping complex results
|
|
* using Sphinx to generate HTML documentation
|
|
|
|
Bugfixes, speed enhancements, and other improvements:
|
|
* compatibility tests should now pass on systems where Python is
|
|
compiled to use 80-bit registers for floating-point operations
|
|
* fixed mpmath to work with some versions of Python 2.4 where a
|
|
list indexing bug is present in the Python core
|
|
* better algorithms for various complex elementary functions
|
|
(tan and tanh by Fredrik; sqrt, acos, asin, acosh and asinh
|
|
improved by Mario Pernici)
|
|
* multiplication and integer powers for complex numbers is faster
|
|
and more accurate
|
|
* miscellaneous speed improvements to complex arithmetic (contributed
|
|
by Mario Pernici)
|
|
* faster computation of cos and sin when only one of them is needed
|
|
(contributed by Mario Pernici)
|
|
* slightly faster square roots at low precision (contributed by
|
|
Mario Pernici)
|
|
* fixed computation of exp(n) for negative integers and x**y for
|
|
negative half integers y
|
|
* mpf ** complex now works
|
|
* faster generation of quadrature nodes (contributed by Mario Pernici)
|
|
* faster change of variables for quadrature
|
|
* comparisons and conversions have been optimized slightly.
|
|
comparisons with float(nan) also work as intended.
|
|
* str() is several times faster at very high precision
|
|
* implementations of most elementary functions moved to the lib
|
|
and libmpc modules for cleaner separation of functionality
|
|
* the rounding argument for lib and libmpc functions, and for
|
|
some functions also the the prec argument, are now optional,
|
|
resulting in cleaner and slightly faster lib code
|
|
* gamma and factorial are about 2x faster
|
|
* polyroots returns nicer results
|
|
* pickling now works for mpf and mpc instances
|
|
|
|
--0.7--
|
|
Released March 12, 2008
|
|
|
|
* the interface for switching precision and rounding modes has been
|
|
changed. instead of changing mpf.prec, there is a new object mp
|
|
which holds the precision as mp.prec. this change improves
|
|
flexibility in the implementation. it will unfortunately break
|
|
any existing code written for mpmath, but the broken code should
|
|
be trivial to update.
|
|
* the functions workprec, workdps, extraprec, extradps have been
|
|
introduced for switching precision in a more safe manner,
|
|
ensuring that the precision gets reset when finished. they can
|
|
be used with the 'with' statement available in python 2.5
|
|
* improved documentation (manual.html)
|
|
* the round-half-down and round-half-up modes have been deprecated,
|
|
since they added complexity without being particularly useful.
|
|
round-half-even has been renamed to round-nearest.
|
|
* implemented the functions nstr, nprint for printing numbers with
|
|
a small or custom number of digits
|
|
* accuracy of cos and sin near roots has been fixed. computing
|
|
sin(x) or cos(x) where x is huge is also much faster
|
|
* implemented a magical constant eps that gives the "machine"
|
|
epsilon
|
|
* additional mathematical functions: implemented Catalan's constant
|
|
and Bessel functions J_n(x) for integer n and real x
|
|
* new functions diff and diffc for numerical differentiation
|
|
* implemented the ldexp function for fast multiplication by 2**n
|
|
* mpf uses rich comparison methods (contributed by Pearu Peterson)
|
|
* epydoc-friendly docstrings (contributed by Pearu Peterson)
|
|
* support creating mpf from float nan or inf
|
|
* fixed printing of complex numbers with negative imaginary part
|
|
* flattened package structure to simplify inclusion of mpmath in other
|
|
packages
|
|
* external classes can interoperate with mpf and mpc instances
|
|
by defining _mpf_ or _mpc_ properties
|
|
* renamed lib.fpow -> lib.fpowi and implemented lib.fpow for general
|
|
real powers. <mpf> ** <mpf> should now be slightly faster and more
|
|
robust
|
|
* the internal number representation has been changed to include
|
|
an explicit sign bit. as a result of this change and other small
|
|
tweaks, arithmetic is up to 20% faster and the total running
|
|
time for mpmath's unit tests has dropped 10%.
|
|
* miscellaneous speed improvements:
|
|
* <mpf> ** <int> is 2-3 times faster (contributed by Mario Pernici)
|
|
* <mpf> * <int> and <int> * <mpf> is roughly twice as fast
|
|
* <int> / <mpf> is roughly twice as fast (contributed by Mario
|
|
Pernici)
|
|
* exp and log are about 10% faster
|
|
* fast computation of e and exp(n) when precision is extremely high
|
|
|
|
--0.6--
|
|
Released January 13, 2008
|
|
|
|
* added the mpi type for interval arithmetic
|
|
* powers with integer exponents are computed with directed rounding
|
|
all the way through to preserve interval bounds more robustly
|
|
(however, the code is not fully tested and may have some bugs)
|
|
* string input to mpf.__new__() can now be unicode
|
|
* mpf.__eq__ now works in pypy
|
|
* infs and nans are now implemented in mpmath.lib, resulting in
|
|
considerable simplification of the mpf class implementation
|
|
* partial support for infs and nans in functions, e.g.
|
|
exp(inf) -> inf and exp(-inf) -> 0 now work.
|
|
* renamed several files. created mpmath.apps and moved tests into
|
|
the main mpmath directory
|
|
* wrote script to permit running unit tests without py.test available
|
|
* improved bit counting code in fadd, fmul and fdiv, plus other
|
|
small performance tweaks, resulting in a 20-30% speedup for
|
|
arithmetic
|
|
|
|
--0.5--
|
|
Released November 24, 2007
|
|
|
|
* added the quad module for arbitrary-precision numerical integration
|
|
* floor and ceil functions available
|
|
* implemented __mod__ and __rmod__ for the mpf class
|
|
* partial support for the special numbers +inf, -inf and nan
|
|
* faster multiplication and division (up to 40% faster with psyco)
|
|
* simplified syntax for conversion function (from_int instead of
|
|
from_int_exact, etc)
|
|
* renamed cgamma to euler
|
|
* more documentation strings
|
|
|
|
--0.4--
|
|
Released November 3, 2007
|
|
|
|
* new string conversion code (much faster; unlimited exponents)
|
|
* fixed bug in factorial (it gave the wrong value, though gamma worked)
|
|
* division now uses a rigorous algorithm for directed rounding
|
|
(mpmath previously used a heuristic that got the last bit wrong
|
|
in 1/10000 of cases)
|
|
* misc. performance improvements (arithmetic is 15% faster)
|
|
* refactored parts of the code; added many more docstrings and tests
|
|
* added a function rand() for generating full-precision random numbers
|
|
* rewrote the benchmark script to compare against Decimal and to
|
|
automatically generate timings with psyco both disabled and enabled
|
|
* rewrote unit tests to use py.test
|
|
|
|
--0.3--
|
|
Released October 5, 2007
|
|
|
|
* fixed high-precision accuracy problem in complex sqrt
|
|
* fixed high-precision accuracy problem in atan and complex log
|
|
* fixed directed rounding for sqrt (always rounded to nearest)
|
|
* implemented all hyperbolic and inverse functions (there are some
|
|
accuracy issues left to sort out)
|
|
* included gamma, factorial, erf, zeta incomplete gamma functions
|
|
* made sin and tan more accurate for complex input very close to 0
|
|
* more docstrings
|
|
* many more tests
|
|
* including a benchmark script
|
|
|
|
-- 0.2 --
|
|
Released October 2, 2007
|
|
|
|
* 50% faster exponential function
|
|
* faster mpf <-> int ops
|
|
* fixed import error in pidigits.py; added demos to source distribution
|
|
* __rmul__ was missing on mpf
|
|
* fixed bitcount bug also for -(2**n-1)
|
|
* more docstrings
|
|
* more tests; tests included in source distribution
|
|
* approximate equality testing (.ae method) supported
|
|
* implemented atan and atan2 functions
|
|
* tan works for both mpfs and mpcs
|
|
* complex logarithms and complex powers supported
|
|
* more details in README
|
|
|
|
-- 0.1 --
|
|
Released September 27, 2007
|
|
|
|
* imported code from SymPy's numerics module
|
|
* renamed functions and restructured various parts of the code
|
|
* fixed erroneous bitcount for 2**n-1 mantissa with directed rounding
|
|
* various small speed improvements and bug fixes
|