mpmath 1.5.0a1__tar.gz → 1.5.0a2__tar.gz

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/.github/CONTRIBUTING.rst

@@ -35,7 +35,7 @@ All work should be submitted via `Pull Requests (PR)`_.
 
 4. Please conform to `PEP 8`_; run::
 
-       flake518
+       ruff check
 
    to check formatting.
 

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/.github/workflows/linter.yml

@@ -1,4 +1,4 @@
-name: Linting with flake8, etc
+name: Linting with ruff, etc
 on: [workflow_dispatch, workflow_call]
 jobs:
   linter:
@@ -10,6 +10,4 @@ jobs:
       - uses: actions/setup-python@v7
         with:
           python-version: "3.x"
-      - run: pip install --upgrade .[develop]
-      - run: python -We:invalid -m compileall -f mpmath -q
-      - run: flake518 mpmath
+      - uses: j178/prek-action@v3.0.0

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/.github/workflows/test.yml

@@ -45,20 +45,27 @@ jobs:
             purepy: true
           - python-version: pypy3.11
             purepy: true
+          - python-version: graalpy-25
+            purepy: true
+          - python-version: pypy3.11
+            nogmpy: true
     env:
       PYTEST_ADDOPTS: -n auto --durations=20
     steps:
     - uses: actions/checkout@v7
       with:
         fetch-depth: 0
+    - run: sudo apt-get update
+    - run: sudo apt-get install zlib1g-dev libjpeg8-dev
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v7
       with:
         python-version: ${{ matrix.python-version }}
         allow-prereleases: true
+        check-latest: true
+    - run: pip install --upgrade setuptools pip
     - name: Install dependencies
       run: |
-        pip install --upgrade setuptools pip
         pip install --upgrade .[develop,gmpy2,gmp,ci]
     - run: pip uninstall -y gmpy2
       if: matrix.nogmpy

mpmath-1.5.0a2/.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+    - id: check-yaml
+    - id: check-toml
+    - id: end-of-file-fixer
+    - id: trailing-whitespace
+    - id: name-tests-test
+      args: [--pytest-test-first]
+      exclude: ^tests/utils.py$
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.3
+    hooks:
+      - id: ruff
+        name: Run ruff
+        args: [--exit-non-zero-on-fix]
+  - repo: https://github.com/sphinx-contrib/sphinx-lint
+    rev: v1.0.0
+    hooks:
+      - id: sphinx-lint
+        name: Run sphinx-lint

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/CHANGES

@@ -18,7 +18,11 @@ Features:
   see #1153 (Sergey B Kirpichev)
 * Add shortest_str context option to enable using shortest decimal
   representations in str/repr/format output, see #1115 (Sergey B Kirpichev)
-* Add fft()/invfft() functions for DFT calculation, see #1152 (Ayush Baranwal)
+* Add fft()/invfft() functions for DFT calculation, see #1152 and
+  #1176 (Ayush Baranwal)
+* Add lll_gram() for LLL reduction, see #1185 (Graham Hesketh)
+* Add Riemann theta functions, rtheta() and rtheta_jet(), see #1182
+  (Graham Hesketh)
 
 Compatibility:
 
@@ -94,6 +98,17 @@ Bug fixes:
 * Avoid spurious overflow in fp gammaprod, see #1150 (Sanjay Santhanam)
 * Document pretty_dps context's option, see #1153 (Sergey B Kirpichev)
 * Fix cplot points rounding, see #1155 (alexfyp)
+* Fix special cases for log1p, atan2, sin, cos, sqrt, hypot, atan,
+  atanh, see #1178, #1179, #1191, #1192 (Matt Haberland)
+* Speedup bin_to_radix for power-of-two bases, see #1187 (Sai Adith Prakash)
+* Fix complex interval conjugation, see #1202 (Christopher Albert)
+* Flip rounding direction when negating in mpf_gamma(type=3),
+  see #1204 (Syed Ahnaf Raza)
+* Use extra working precision in mpf_atan2 for directed rounding
+  and fix mpi_atan2() for y == 0 with x spanning zero, see #1203
+  (Syed Ahnaf Raza)
+* Accept spelled-out infinity in from_str(), see #1208 (Rahul)
+* Add missing degree constant to the FPContext, see #1207 (Rahul)
 
 Maintenance:
 
@@ -105,6 +120,8 @@ Maintenance:
 * Fix test_sn_cn_dn_identities(), see #1106 (Sergey B Kirpichev)
 * Fix test_compatibility(): avoid using of private numpy
   API (Sergey B Kirpichev)
+* Use prek, see #1184 (Sergey B Kirpichev)
+* Use new version of python-gmp in CI, see #1197 (Sergey B Kirpichev)
 
 
 --1.4.1--
@@ -723,7 +740,7 @@ General changes:
   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) 
+  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)

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpmath
-Version: 1.5.0a1
+Version: 1.5.0a2
 Summary: Python library for arbitrary-precision floating-point arithmetic
 Author-email: Fredrik Johansson <fredrik.johansson@gmail.com>
 License-Expression: BSD-3-Clause
@@ -22,26 +22,26 @@ Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Implementation :: GraalPy
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Provides-Extra: tests
 Requires-Dist: pytest>=6; extra == "tests"
-Requires-Dist: numpy; python_version < "3.15" and extra == "tests"
+Requires-Dist: numpy; extra == "tests"
 Requires-Dist: packaging; extra == "tests"
 Requires-Dist: pytest-timeout; extra == "tests"
-Requires-Dist: matplotlib; python_version < "3.15" and extra == "tests"
+Requires-Dist: matplotlib; platform_python_implementation != "GraalVM" and extra == "tests"
 Requires-Dist: pexpect; extra == "tests"
 Requires-Dist: ipython; extra == "tests"
 Requires-Dist: hypothesis; extra == "tests"
 Provides-Extra: develop
 Requires-Dist: mpmath[tests]; extra == "develop"
-Requires-Dist: flake518>=1.5; extra == "develop"
 Requires-Dist: pytest-cov>=7; extra == "develop"
 Requires-Dist: wheel; extra == "develop"
 Requires-Dist: build; extra == "develop"
 Provides-Extra: gmpy2
-Requires-Dist: gmpy2>=2.3; extra == "gmpy2"
+Requires-Dist: gmpy2>=2.3; platform_python_implementation != "GraalVM" and extra == "gmpy2"
 Provides-Extra: gmpy
 Requires-Dist: mpmath[gmpy2]; extra == "gmpy"
 Provides-Extra: gmp
@@ -106,6 +106,7 @@ or new features to mpmath:
 * Nike Dattani <nike@hpqc.org>
 * Tim Peters <tim.peters@gmail.com>
 * Javier Garcia <javier.garcia.tw@hotmail.com>
+* Graham Hesketh <gdh1e10@gmail.com>
 
 Numerous other people have contributed by reporting bugs,
 requesting new features, or suggesting improvements to the
@@ -130,8 +131,8 @@ Credit also goes to:
 * The authors of the GMP library and the Python wrapper
   gmpy, enabling mpmath to become much faster at
   high precision
-* The authors of MPFR, pari/gp, MPFUN, and other arbitrary-
-  precision libraries, whose documentation has been helpful
+* The authors of MPFR, pari/gp, MPFUN, and other arbitrary-precision
+  libraries, whose documentation has been helpful
   for implementing many of the algorithms in mpmath
 * Wikipedia contributors; Abramowitz & Stegun; Gradshteyn & Ryzhik;
   Wolfram Research for MathWorld and the Wolfram Functions site.
@@ -173,7 +174,7 @@ Release history:
 --------------------------
 
 Mpmath requires Python 3.10 or later versions.  It has been tested with CPython
-3.10 through 3.15 and for PyPy 3.11.
+3.10 through 3.15, with PyPy 7.3.23 and with GraalPy 25.3.
 
 The latest release of mpmath can be downloaded from the mpmath
 website and from https://github.com/mpmath/mpmath/releases

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/README.rst

@@ -49,6 +49,7 @@ or new features to mpmath:
 * Nike Dattani <nike@hpqc.org>
 * Tim Peters <tim.peters@gmail.com>
 * Javier Garcia <javier.garcia.tw@hotmail.com>
+* Graham Hesketh <gdh1e10@gmail.com>
 
 Numerous other people have contributed by reporting bugs,
 requesting new features, or suggesting improvements to the
@@ -73,8 +74,8 @@ Credit also goes to:
 * The authors of the GMP library and the Python wrapper
   gmpy, enabling mpmath to become much faster at
   high precision
-* The authors of MPFR, pari/gp, MPFUN, and other arbitrary-
-  precision libraries, whose documentation has been helpful
+* The authors of MPFR, pari/gp, MPFUN, and other arbitrary-precision
+  libraries, whose documentation has been helpful
   for implementing many of the algorithms in mpmath
 * Wikipedia contributors; Abramowitz & Stegun; Gradshteyn & Ryzhik;
   Wolfram Research for MathWorld and the Wolfram Functions site.
@@ -116,7 +117,7 @@ Release history:
 --------------------------
 
 Mpmath requires Python 3.10 or later versions.  It has been tested with CPython
-3.10 through 3.15 and for PyPy 3.11.
+3.10 through 3.15, with PyPy 7.3.23 and with GraalPy 25.3.
 
 The latest release of mpmath can be downloaded from the mpmath
 website and from https://github.com/mpmath/mpmath/releases

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/conftest.py

@@ -15,15 +15,6 @@ def pytest_report_header(config):
 def pytest_configure(config):
     config.addinivalue_line('markers', 'slow: marks tests as slow')
 
-    if "no:hypothesispytest" not in config.getoption("-p"):
-        from hypothesis import settings
-
-        default = settings.get_profile("default")
-        settings.register_profile("default",
-                                  settings(default, max_examples=1000))
-        ci = settings.get_profile("ci")
-        settings.register_profile("ci", settings(ci, max_examples=10000))
-
 
 @pytest.fixture(autouse=True)
 def reset_mp_globals():

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/docs/basics.rst

@@ -209,6 +209,20 @@ Note that when creating a new ``mpf``, the value will at most be as accurate as
 
 (Binary fractions such as 0.5, 1.5, 0.75, 0.125, etc, are generally safe as input, however, since those can be represented exactly by Python floats.)
 
+You always can use hexadecimal or binary strings of didits to specify exact
+value unambiguously:
+
+    >>> mpf("0x1.5544cb90d4f68p-2")
+    mpf('0.33327024528011018')
+    >>> mpf("1.5544cb90d4f68p-2", base=16)
+    mpf('0.33327024528011018')
+    >>> f"{_:a}"
+    '0x1.5544cb90d4f68p-2'
+    >>> mpf("0b1.0101010101000100110010111001000011010100111101101p-2")
+    mpf('0.33327024528011018')
+    >>> f"{_:b}"
+    '1.0101010101000100110010111001000011010100111101101p-2'
+
 Printing
 --------
 
@@ -281,3 +295,42 @@ changing the working precision, use :func:`format syntax support
     '0.16666667'
     >>> f'{a:.50}'
     '0.16666666666666665741480812812369549646973609924316'
+
+Use mpmath CLI
+--------------
+
+It's possible to :ref:`run the mpmath as a module <cli>` (``python -m
+mpmath``).  This provides access to the Python (or IPython) shell, where all
+public mpmath interfaces are imported.  Also, per default, floating-point
+literals (decimal, binary or hexadecimal) are parsed as ``mpf``/``mpc`` and
+``str()``-style output for ``repr()`` is enabled.  Here is an example of
+IPython-powered shell session:
+
+.. code:: text
+
+    In [1]: 0b1.1011p-2  # binary input
+    Out[1]: 0.421875
+
+    In [2]: gamma(_)
+    Out[2]: 2.1008334194214666
+
+    In [3]: sin(1)
+    Out[3]: 0.8414709848078965
+
+    In [4]: type(_)
+    Out[4]: mpmath.ctx_mp_python.mpf
+
+    In [5]: acos(0x1.bp13)  # hexadecimal input
+    Out[5]: (0.0 + 10.227308670295587j)
+
+    In [6]: type(_)
+    Out[6]: mpmath.ctx_mp_python.mpc
+
+    In [7]: 0.8414709848078965j  # decimal input
+    Out[7]: (0.0 + 0.8414709848078965j)
+
+    In [8]: _7.imag == _3
+    Out[8]: True
+
+    In [9]: type(_7)
+    Out[9]: mpmath.ctx_mp_python.mpf

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/docs/calculus/fft.rst

@@ -10,4 +10,4 @@ FFT
 Inverse FFT
 ...........
 
-.. autofunction:: mpmath.invfft
+.. autofunction:: mpmath.invfft

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/docs/calculus/sums_limits.rst

@@ -64,4 +64,3 @@ properties of the algorithms.
 :func:`~mpmath.cohen_alt`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 .. autofunction:: mpmath.cohen_alt
-

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/docs/contexts.rst

@@ -334,7 +334,7 @@ Due to intermediate rounding and cancellation errors, results computed with ``fp
 
 Beware that the ``fp`` context has signed zero, that can be used to distinguish
 different sides of branch cuts.  For example, ``fp.mpc(-1, -0.0)`` is treated
-as though it lies *below* the branch cut for :func:`~mpmath.sqrt()`::
+as though it lies *below* the branch cut for :func:`~mpmath.sqrt`::
 
     >>> fp.sqrt(fp.mpc(-1, -0.0))
     -1j
@@ -366,5 +366,5 @@ one has no signed zeros and allows to specify result *on the branch cut*
     >>> fp.mpc(mp.sqrt(-1))
     1j
 
-Here it's continuous from the above of the :func:`~mpmath.sqrt()` branch
+Here it's continuous from the above of the :func:`~mpmath.sqrt` branch
 cut (from ``0`` along the negative real axis to the negative infinity).

mpmath-1.5.0a2/docs/functions/abelian.rst

@@ -0,0 +1,39 @@
+Abelian functions
+-----------------
+
+Riemann theta functions generalize the Jacobi theta functions from one
+complex variable to several. They arose in Riemann's nineteenth-century
+theory of Abelian functions and compact Riemann surfaces. Today they are
+fundamental tools in complex analysis and algebraic geometry, and occur in
+finite-gap and quasiperiodic solutions of integrable systems.
+
+In genus :math:`g`, the argument :math:`\mathbf{z}\in\mathbb C^g` is a
+column vector and the period matrix
+:math:`\boldsymbol{\tau}\in\mathbb C^{g\times g}` is symmetric with
+positive-definite imaginary part.
+
+Theta functions are quasiperiodic. For integer vectors
+:math:`\mathbf{m},\mathbf{n}\in\mathbb Z^g`, the zero-characteristic function
+satisfies
+
+.. math ::
+
+    \theta(\mathbf{z}+\mathbf{m}+\boldsymbol{\tau}\,\mathbf{n}
+           \mid\boldsymbol{\tau})
+    = \exp\!\left(-\pi i\,\mathbf{n}^{T}\boldsymbol{\tau}\,\mathbf{n}
+                  -2\pi i\,\mathbf{n}^{T}\mathbf{z}\right)
+      \theta(\mathbf{z}\mid\boldsymbol{\tau}).
+
+Although theta functions are quasiperiodic, suitable ratios and combinations
+of them give multiply-periodic Abelian functions. In genus two, such Abelian
+functions are meromorphic functions of two complex variables with a period
+lattice of rank four, generated in normalized coordinates by the columns of
+:math:`\mathbf{I}_2` and :math:`\boldsymbol{\tau}`.
+
+
+Riemann theta functions
+.......................
+
+.. autofunction:: mpmath.rtheta
+
+.. autofunction:: mpmath.rtheta_jet

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/docs/functions/index.rst

@@ -17,6 +17,7 @@ Mpmath implements the standard functions from Python's ``math`` and ``cmath`` mo
    orthogonal
    hypergeometric
    elliptic
+   abelian
    zeta
    numtheory
    qfunctions

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/docs/identification.rst

@@ -9,6 +9,11 @@ Automated number recognition based on PSLQ is not a silver bullet. Any occurring
 
 The number identification facilities in mpmath are inspired by the `Inverse Symbolic Calculator <http://wayback.cecm.sfu.ca/projects/ISC/ISCmain.html>`_ (ISC). The ISC is more powerful than mpmath, as it uses a lookup table of millions of precomputed constants (thereby mitigating the problem with exponential complexity).
 
+LLL lattice reduction is also documented below. A basis generates a lattice
+from all its integer linear combinations; ``lll_gram`` reduces that basis
+using its Gram matrix, without requiring the basis vectors themselves. The
+reduced basis can reveal integer relations, as the example below illustrates.
+
 Constant recognition
 -----------------------------------
 
@@ -29,3 +34,8 @@ Integer relations (PSLQ)
 :func:`~mpmath.pslq`
 ^^^^^^^^^^^^^^^^^^^^^
 .. autofunction:: mpmath.pslq
+
+Lattice reduction (LLL)
+-----------------------
+
+.. autofunction:: mpmath.lll_gram

mpmath-1.5.0a2/docs/plots/rtheta.py

@@ -0,0 +1,12 @@
+import matplotlib.pyplot as plt
+from mpmath import j, plot, re, rtheta
+
+tau = [[j, -0.5], [-0.5, j]]
+curves = [
+    lambda x: re(rtheta([x, x/2], tau)),
+    lambda x: re(rtheta([x, 2*x], tau)),
+]
+fig, ax = plt.subplots()
+plot(curves, [-2, 2], axes=ax)
+ax.legend([r"$z=(x,x/2)$", r"$z=(x,2x)$"])
+fig.savefig("rtheta.png")

mpmath-1.5.0a2/docs/plots/rtheta_surface.py

@@ -0,0 +1,9 @@
+import matplotlib.pyplot as plt
+from mpmath import j, rtheta, splot
+
+tau = [[j, 0.5], [0.5, j]]
+fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+surface = lambda x, y: abs(rtheta([x, y], tau))
+splot(surface, [-1, 1], [-1, 1], points=35, keep_aspect=False, axes=ax, plot3d_kwargs={"cmap": "viridis"})
+ax.set_zlabel(r"$|\theta(z\mid\tau)|$")
+fig.savefig("rtheta_surface.png")

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/docs/plotting.rst

@@ -37,4 +37,3 @@ Complex function plots
    splot(f, [0, 2*pi], [0, 2*pi])
 
 .. autofunction:: mpmath.splot
-

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/docs/setup.rst

@@ -145,7 +145,7 @@ In Sage, mpmath can alternatively be imported via the interface library
     sage: import sage.libs.mpmath.all as mpmath
 
 This module provides a few extra conversion functions, including ``mpmath.call()``
-which permits calling any mpmath function with Sage numbers as input, and getting 
+which permits calling any mpmath function with Sage numbers as input, and getting
 Sage ``RealNumber`` or ``ComplexNumber`` instances
 with the appropriate precision back::
 

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/docs/technical.rst

@@ -22,7 +22,7 @@ The following terms are common in this documentation:
 - *Accuracy* is the inverse of error.
 - *Tolerance* is the maximum error (or minimum accuracy) desired in a result.
 
-Error and accuracy can be measured either directly, or logarithmically in bits or digits. Specifically, if a `\hat y` is an approximation for `y`, then 
+Error and accuracy can be measured either directly, or logarithmically in bits or digits. Specifically, if a `\hat y` is an approximation for `y`, then
 
 - (Direct) absolute error = `|\hat y - y|`
 - (Direct) relative error = `|\hat y - y| |y|^{-1}`

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/mpmath/__init__.py

@@ -47,6 +47,8 @@ g2g3from = mp.g2g3from
 omega1omega2from = mp.omega1omega2from
 ellipfun = mp.ellipfun
 jtheta = mp.jtheta
+rtheta = mp.rtheta
+rtheta_jet = mp.rtheta_jet
 kleinj = mp.kleinj
 kleinjinv = mp.kleinjinv
 eta = mp.eta
@@ -169,6 +171,7 @@ residual = mp.residual
 qr_solve = mp.qr_solve
 cholesky = mp.cholesky
 cholesky_solve = mp.cholesky_solve
+lll_gram = mp.lll_gram
 det = mp.det
 cond = mp.cond
 hessenberg = mp.hessenberg

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/mpmath/__main__.py

@@ -71,6 +71,8 @@ def main():
 
     try:
         import IPython
+        import IPython.terminal
+        import IPython.terminal.ipapp
         import traitlets
     except ImportError:
         args.no_ipython = True
@@ -94,7 +96,7 @@ def main():
             source = """
 from mpmath._interactive import wrap_float_literals, wrap_hexbinfloats
 ip = get_ipython()
-ip.input_transformers_post.append(wrap_float_literals)
+ip.input_transformers_post.append(wrap_hexbinfloats)
 ip.input_transformers_post.append(wrap_float_literals)
 del ip
 """

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/mpmath/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0a1'
-__version_tuple__ = version_tuple = (1, 5, 0, 'a1')
+__version__ = version = '1.5.0a2'
+__version_tuple__ = version_tuple = (1, 5, 0, 'a2')
 
-__commit_id__ = commit_id = 'gd8c4597a7'
+__commit_id__ = commit_id = 'gc4c7a6494'

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/mpmath/calculus/fft.py

@@ -1,5 +1,14 @@
 from .calculus import defun
 
+
+def _is_power_of_two(n):
+    return (n & (n - 1)) == 0
+
+
+def _next_power_of_two(n):
+    return 1 << (n - 1).bit_length()
+
+
 def _fft_cooley_tuckey(ctx, values, inverse=False):
     """
     This function implements the Radix-2 Cooley-Tukey FFT algorithm iteratively.
@@ -46,12 +55,52 @@ def _fft_cooley_tuckey(ctx, values, inverse=False):
 
     return transformed
 
+
+def _fft_convolve(ctx, values_a, values_b):
+    """
+    Computes the convolution of two sequences using the Fast Fourier Transform (FFT).
+    """
+    size = _next_power_of_two(len(values_a) + len(values_b) - 1)
+    padded_a = values_a + [ctx.zero] * (size - len(values_a))
+    padded_b = values_b + [ctx.zero] * (size - len(values_b))
+
+    spectrum_a = _fft_cooley_tuckey(ctx, padded_a)
+    spectrum_b = _fft_cooley_tuckey(ctx, padded_b)
+    spectrum_product = [a * b for a, b in zip(spectrum_a, spectrum_b)]
+    result = _fft_cooley_tuckey(ctx, spectrum_product, True)
+    return [value / size for value in result]
+
+
+def _fft_bluestein(ctx, values, inverse=False):
+    """
+    This function implements Bluestein's algorithm for FFT
+    (or Inverse FFT) calulation.
+
+    https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein's_algorithm
+    """
+    n = len(values)
+
+    sign = ctx.one if inverse else -ctx.one
+    chirp = [ctx.expjpi(sign * j * j / n) for j in range(n)]
+
+    a = [values[j] * chirp[j] for j in range(n)]
+    b = [ctx.zero] * (2 * n - 1)
+    center = n - 1
+    for j in range(n):
+        b[center + j] = ctx.expjpi(-sign * j * j / n)
+        b[center - j] = ctx.expjpi(-sign * j * j / n)
+
+    convolution = _fft_convolve(ctx, a, b)
+    return [convolution[n - 1 + k] * chirp[k] for k in range(n)]
+
+
 @defun
 def fft(ctx, values):
     r"""
     Computes the Discrete Fourier Transform (DFT) of a sequence.
 
-    Raises NotImplementedError if the input sequence length is not a power of 2.
+    It uses the radix-2 Cooley-Tukey algorithm for power-of-two lengths
+    and Bluestein's algorithm for all other lengths.
 
     **Examples**
 
@@ -63,27 +112,29 @@ def fft(ctx, values):
     [(2.0 + 4.0j), (0.0 + 0.0j)]
     >>> mp.fft([1, 2, 3, 4])
     [10.0, (-2.0 + 2.0j), -2.0, (-2.0 - 2.0j)]
+    >>> [mp.chop(x) for x in mp.fft([1, 2, 1])]
+    [4.0, (-0.5 - 0.866025403784439j), (-0.5 + 0.866025403784439j)]
     """
     n = len(values)
     if n == 0:
         return []
 
-    is_power_of_two = (n & (n - 1)) == 0
-    if not is_power_of_two:
-        raise NotImplementedError("FFT is only implemented for lengths that "
-                                  f"are powers of 2, got length: {n}")
-
     converted_values = [ctx.convert(v) for v in values]
     with ctx.extraprec(10):
-        result = _fft_cooley_tuckey(ctx, converted_values)
+        if _is_power_of_two(n):
+            result = _fft_cooley_tuckey(ctx, converted_values)
+        else:
+            result = _fft_bluestein(ctx, converted_values)
     return [+v for v in result]
 
+
 @defun
 def invfft(ctx, values):
     r"""
     Computes the inverse Discrete Fourier Transform (IDFT) of a sequence.
 
-    Raises NotImplementedError if the input sequence length is not a power of 2.
+    It uses the radix-2 Cooley-Tukey algorithm for power-of-two lengths
+    and Bluestein's algorithm for all other lengths.
 
     **Examples**
 
@@ -94,17 +145,17 @@ def invfft(ctx, values):
     >>> x = [1, 2, 3, 4]
     >>> mp.invfft(mp.fft(x))
     [(1.0 + 0.0j), (2.0 + 0.0j), (3.0 + 0.0j), (4.0 + 0.0j)]
+    >>> mp.invfft(mp.fft([1.0 + 1.0j, 2.0 + 2.0j, 3.0 + 3.0j]))
+    [(1.0 + 1.0j), (2.0 + 2.0j), (3.0 + 3.0j)]
     """
     n = len(values)
     if n == 0:
         return []
 
-    is_power_of_two = (n & (n - 1)) == 0
-    if not is_power_of_two:
-        raise NotImplementedError("Inverse FFT is only implemented for lengths that "
-                                  f"are powers of 2, got length: {n}")
-
     converted_values = [ctx.convert(v) for v in values]
     with ctx.extraprec(10):
-        result = _fft_cooley_tuckey(ctx, converted_values, True)
+        if _is_power_of_two(n):
+            result = _fft_cooley_tuckey(ctx, converted_values, True)
+        else:
+            result = _fft_bluestein(ctx, converted_values, True)
     return [val / n for val in result]

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/mpmath/ctx_fp.py

@@ -84,6 +84,7 @@ class FPContext(StandardBaseContext):
     khinchin = 2.6854520010653064453
     apery = 1.2020569031595942854
     glaisher = 1.2824271291006226369
+    degree = 0.017453292519943295
 
     absmin = absmax = abs
 

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/mpmath/ctx_iv.py

@@ -207,7 +207,7 @@ class ivmpc:
 
     def conjugate(s):
         a, b = s._mpci_
-        return s.ctx.make_mpc((a, mpf_neg(b)))
+        return s.ctx.make_mpc((a, mpi_neg(b)))
 
     def overlap(s, t):
         t = s.ctx.convert(t)

{mpmath-1.5.0a1 → mpmath-1.5.0a2}/mpmath/ctx_mp.py

@@ -806,7 +806,7 @@ maxterms, or set zeroprec."""
         """
         x = ctx.convert(x)
         *_, e, bc = x._mpf_
-        return ctx.make_mpf((0, 1, e + bc - ctx.prec, 1))
+        return ctx.make_mpf((0, MPZ_ONE, e + bc - ctx.prec, 1))
 
     def fneg(ctx, x, prec=None, dps=None, rounding=round_nearest, exact=False):
         """