Metadata-Version: 2.4
Name: python-flint
Version: 0.9.0
Summary: Bindings for FLINT
Author-Email: Fredrik Johansson <fredrik.johansson@gmail.com>, Oscar Benjamin <oscar.j.benjamin@gmail.com>
License-Expression: MIT AND LGPL-3.0-or-later AND (MIT AND BSD-3-Clause-Clear) AND (GPL-3.0-or-later WITH GCC-exception-3.1 AND LGPL-2.1-or-later)
License-File: LICENSE
License-File: python-flint.libs/gmp-6.3.0/COPYING
License-File: python-flint.libs/gmp-6.3.0/COPYING.LESSERv3
License-File: python-flint.libs/mpfr-4.2.2/COPYING
License-File: python-flint.libs/mpfr-4.2.2/COPYING.LESSER
License-File: python-flint.libs/flint-3.6.0/COPYING
License-File: python-flint.libs/flint-3.6.0/COPYING.LESSER
License-File: python-flint.libs/winpthreads/COPYING
License-File: python-flint.libs/gcc/COPYING3
License-File: python-flint.libs/gcc/COPYING.LIB
License-File: python-flint.libs/gcc/COPYING.RUNTIME
Classifier: Topic :: Scientific/Engineering :: Mathematics
Project-URL: Homepage, https://github.com/flintlib/python-flint
Project-URL: Documentation, https://python-flint.readthedocs.io/en/latest/
Project-URL: Repository, https://github.com/flintlib/python-flint
Project-URL: Changelog, https://github.com/flintlib/python-flint/blob/master/README.md#changelog
Requires-Python: >=3.10
Description-Content-Type: text/markdown

Python-FLINT
============

Python extension module wrapping FLINT (Fast Library for Number Theory)
and Arb (arbitrary-precision ball arithmetic). Features:

* Integers, rationals, integers mod n
* Real and complex numbers with rigorous error tracking
* Polynomials, power series and matrices over all the above types
* Lots of mathematical functions

Documentation: https://python-flint.readthedocs.io/en/latest/

Repository: https://github.com/flintlib/python-flint/

Author: Fredrik Johansson <fredrik.johansson@gmail.com>

Installation
------------

Currently python-flint supports CPython versions 3.10-3.14 and 3.14t
(free-threaded) and provides binaries on PyPI for the following platforms:

- Windows (x86-64)
- MacOS (x86-64, arm64)
- Linux (manylinux: x86-64, aarch64)

For these platforms python-flint can be installed simply with `pip`

    pip install python-flint

Alternatively python-flint can be installed using `conda`

    conda install -c conda-forge python-flint

Build from source
-----------------

For other platforms or architectures installation needs to build from source.
First install FLINT 3. Starting with python-flint 0.5.0 older versions of Flint
such as 2.9 are not supported any more. Note that as of Flint 3 Arb no longer
needs to be built separately as it is now merged into Flint.

As of e.g. Ubuntu 24.04 a new enough version of FLINT (at least version 3) can
be installed from the Ubuntu repos like

    sudo apt-get install libflint-dev

For older distros the version in the repos is too old and a newer version of
FLINT needs to be built. See here for instructions on building FLINT:

* http://flintlib.org/

A script that builds and installs FLINT on Ubuntu can be found here:

* https://github.com/flintlib/python-flint/blob/master/bin/install_flint_ubuntu.sh

The latest release of Python-FLINT can then be built from source and installed
using:

    pip install --no-binary python-flint python-flint

Python-FLINT can also be installed from a git checkout or a source archive
as follows:

    pip install .

See the documentation for further notes on building and installing
python-flint:

* https://python-flint.readthedocs.io/en/latest/build.html
* https://python-flint.readthedocs.io/en/latest/install.html

Examples
-------------------------------------

Import Python-FLINT:

    >>> from flint import *

Number-theoretic functions:

    >>> fmpz(1000).partitions_p()
    24061467864032622473692149727991
    >>> fmpq.bernoulli(64)
    -106783830147866529886385444979142647942017/510

Polynomial arithmetic:

    >>> a = fmpz_poly([1,2,3]); b = fmpz_poly([2,3,4]); a.gcd(a * b)
    3*x^2 + 2*x + 1
    >>> a = fmpz_poly(list(range(10001))); b = fmpz_poly(list(range(10000))); a.gcd(a * b).degree()
    10000
    >>> x = fmpz_poly([0,1]); ((1-x**2)*(1+x**3)**3*(1+x+2*x)).factor()
    (-1, [(3*x + 1, 1), (x + (-1), 1), (x^2 + (-1)*x + 1, 3), (x + 1, 4)])

Matrix arithmetic:

    >>> fmpz_mat([[1,1],[1,0]]) ** 10
    [89, 55]
    [55, 34]
    >>> fmpq_mat.hilbert(10,10).det()
    1/46206893947914691316295628839036278726983680000000000

Numerical evaluation:

    >>> showgood(lambda: (arb.pi() * arb(163).sqrt()).exp() - 640320**3 - 744, dps=25)
    -7.499274028018143111206461e-13
    >>> showgood(lambda: (arb.pi() * 10**100 + arb(1)/1000).sin(), dps=25)
    0.0009999998333333416666664683

Numerical integration:

    >>> ctx.dps = 30
    >>> acb.integral(lambda x, _: (-x**2).exp(), -100, 100) ** 2
    [3.141592653589793238462643383 +/- 3.11e-28]

To do
-------------------------------------

* Write more tests and add missing docstrings
* Wrap missing flint types: matrices over finite fields, p-adic numbers, rational functions
* Build on the preliminary interface to FLINT's generic (gr) types.
* Make a nicer interface like `ZZ(1)` etc rather than `fmpz_poly([1, 2])`.
* Vector or array types (maybe)
* Many convenience methods
* Write generic implementations of functions missing for specific FLINT types
* Proper handling of special values in various places (throwing Python
  exceptions instead of aborting, etc.)
* Various automatic conversions
* Conversions to and from external types (numpy, sage, sympy, mpmath, gmpy)
* Improved printing and string input/output
* IPython hooks (TeX pretty-printing etc.)

Compatibility table
-------------------

Generally each release of python-flint will be compatible with a range of
Python versions. Since python-flint 0.5.0 the minimum supported Flint version
is `3.0` and each release of python-flint supports all versions of Flint
`>=3.0` available at the time of release.

Compatible versions:

| python-flint | Release date  | CPython     | FLINT      | Cython           |
|--------------|---------------|-------------|------------|------------------|
| `0.9.0`      |  3rd Jul 2026 | `3.10-3.14` | `3.0-3.6`  | `3.1-3.2`        |
| `0.8.0`      | 29th Aug 2025 | `3.11-3.14` | `3.0-3.3`  | `3.1` only       |
| `0.7.0`      | 16th Mar 2025 | `3.11-3.13` | `3.0-3.2`  | `3.0.11-3.1.0a1` |
| `0.6.0`      |  1st Feb 2024 | `3.9-3.12`  | `3.0` only | `3.0` only       |

The requirement for Cython 3.1 is only for CPython's free-threaded build.
Otherwise Cython 3.0 is fine. Cython 3.2 is required for a stable ABI build of
python-flint.

As of python-flint 0.7.0, CPython 3.13 [PEP
703](https://peps.python.org/pep-0703/) free-threaded (no-GIL) builds of
python-flint are provided. In the the free-threaded build, mutating matrices or
polynomials from multiple threads can lead to memory corruption. There are some
other known issues with the free-threaded build so it should be considered
experimental.

CHANGELOG
=========

0.9.0
-----

Contributors (0.9.0):

- Rémy Oudompheng (RO)
- Agriya Khetarpal (AK)
- Oscar Benjamin (OB)
- Daniel Simmons-Marengo (DSM)
- ForeverHaibara (FH)
- Jeroen Hanselman (JH)
- Sam Schiavone (SS)

Changes (0.9.0):

- [gh-322](https://github.com/flintlib/python-flint/pull/322),
  Add `mul_low` and `pow_trunc` methods to `fmpz_poly`, `fmpq_poly` and
  `nmod_poly`. (RO)
- [gh-318](https://github.com/flintlib/python-flint/pull/318),
  Add emscripten build in CI. Polynomial factors and roots are
  now sorted into a consistent order for `nmod_poly` and
  `fq_default_poly`. Some tests are fixed so that they pass on
  32-bit systems. (AK, OB)
- [gh-312](https://github.com/flintlib/python-flint/pull/312),
  Add `discriminant` method to `fmpz_poly`, `fmpq_poly` and
  `nmod_poly`. (RO)
- [gh-336](https://github.com/flintlib/python-flint/pull/336),
  Fixed a bug in `arb.neg()` which caused it to return its input
  without negating it. (DSM)
- [gh-339](https://github.com/flintlib/python-flint/pull/339),
  Add `fmpq.__float__` method so that `float(fmpq)` and `complex(fmpq)`
  work. (OB)
- [gh-324](https://github.com/flintlib/python-flint/pull/324),
  Faster conversion from `int` to `fmpz` and back. (RO).
- [gh-326](https://github.com/flintlib/python-flint/pull/326),
  Add support for building with the Python stable ABI. (OB)
- [gh-341](https://github.com/flintlib/python-flint/pull/341),
  Disable hashing for inexact `arb` values. (DSM)
- [gh-347](https://github.com/flintlib/python-flint/pull/347),
  Fix storing the variable name for `fq_default`. (OB)
- [gh-350](https://github.com/flintlib/python-flint/pull/350),
  Add support for Cython 3.2. (OB)
- [gh-352](https://github.com/flintlib/python-flint/pull/352),
  Fix a crash in `fmpz_mat.lll()` for empty matrices. (OB)
- [gh-359](https://github.com/flintlib/python-flint/pull/359),
  Sort factorisations of all mpoly types. (OB)
- [gh-367](https://github.com/flintlib/python-flint/pull/367),
  Add type stubs and tests for many more classes. (OB)
- [gh-370](https://github.com/flintlib/python-flint/pull/370),
  Fix `unused_gens()` for the zero polynomial. (OB)
- [gh-374](https://github.com/flintlib/python-flint/pull/374),
  Fixed a bug in `nmod.__hash__`. (FH)
- [gh-378](https://github.com/flintlib/python-flint/pull/378),
  Build Windows extension modules with MSVC. (OB)
- [gh-379](https://github.com/flintlib/python-flint/pull/379),
  Add Windows ARM64 wheels. (OB)
- [gh-380](https://github.com/flintlib/python-flint/pull/380),
  Support building against FLINT 3.4.0. (OB)
- [gh-393](https://github.com/flintlib/python-flint/pull/393),
  Use `fmpz_mod_mat_det()` when building against FLINT 3.1 or newer. (OB)
- [gh-401](https://github.com/flintlib/python-flint/pull/401),
  Upload Pyodide wheels to PyPI. (OB)
- [gh-389](https://github.com/flintlib/python-flint/pull/389),
  [gh-402](https://github.com/flintlib/python-flint/pull/402),
  Support building against FLINT 3.5.0. (OB)
- [gh-392](https://github.com/flintlib/python-flint/pull/392),
  Add interface to `acb_theta_jet` (JH, SS)
- [gh-409](https://github.com/flintlib/python-flint/pull/409),
  Support building against FLINT 3.6.0. (OB)

0.8.0
-----

Contributors (0.8.0):

- Oscar Benjamin (OB)
- Robert Dougherty-Bliss (RDB)
- Rémy Oudompheng (RO)
- Agriya Khetarpal (AK)

Notes (0.8.0):

- This mostly a maintenance release with some bug fixes,
  dependency updates and a few smaller features.
- Since GitHub Actions is retiring its MacOS x86-64 runners
  python-flint 0.8.0 is likely the last release to provide
  prebuilt wheels for MacOS x86-64 (MacOS arm64 remains
  fully supported). It is likely that future versions will
  still work fine on MacOS x86-64 but would require building
  from source and will not be tested in python-flint's CI.
  MacOS arm64 wheels will still be provided and tested.

Changes (0.8.0):

- [gh-302](https://github.com/flintlib/python-flint/pull/302),
  [gh-283](https://github.com/flintlib/python-flint/pull/283),
  [gh-284](https://github.com/flintlib/python-flint/pull/284),
  Wheels now ship MPFR 4.2.2 and FLINT 3.3.1. Cython 3.1 is now
  supported for building (and required for the freethreaded
  build). Wheels are provided for CPython 3.14 and 3.14t
  (free-threaded) and PyPy 3.11. (OB)
- [gh-310](https://github.com/flintlib/python-flint/pull/310),
  Add `truncate`, `left_shift` and `right_shift` methods to
  `fmpz_poly`, `fmpq_poly`, `nmod_poly`, `acb_poly`, `arb_poly`
  to match other univariate polynomial types. (RO)
- [gh-287](https://github.com/flintlib/python-flint/pull/287),
  [gh-293](https://github.com/flintlib/python-flint/pull/293),
  [gh-305](https://github.com/flintlib/python-flint/pull/305),
  [gh-307](https://github.com/flintlib/python-flint/pull/307),
  [gh-309](https://github.com/flintlib/python-flint/pull/309),
  Add type annotations for `fmpz`, `fmpq`, `nmod`, `fmpz_mod`,
  `fq_default`, `fmpz_poly`, `fmpq_poly`, `nmod_poly`,
  `fmpz_mod_poly`, `fq_default_poly`, `fmpz_mpoly`, `fmpq_mpoly`,
  `nmod_mpoly`, `fmpz_mod_mpoly`, `fmpz_series` and `fmpq_series`
  (about half of the codebase). (OB)
- [gh-300](https://github.com/flintlib/python-flint/pull/300),
  Fix `arb.repr` which now returns a Python representation that
  round trips. (OB)
- [gh-292](https://github.com/flintlib/python-flint/pull/292),
  The `fmpq` constructor now accepts `fmpq` numerator and denominator
  as input. (OB)
- [gh-289](https://github.com/flintlib/python-flint/pull/289),
  Add `.prec` attribute to series types `fmpz_series`, `fmpq_series`,
  `arb_series` and `acb_series`. (OB)
- [gh-285](https://github.com/flintlib/python-flint/pull/285),
  Don't use deprecated meson build option. (AK)
- [gh-274](https://github.com/flintlib/python-flint/pull/274),
  Add resultant methods to `fmpz_poly`, `fmpq_poly` and
  `nmod_poly`. Now all univariate and polynomial types have the
  resultant method except for `fq_default_poly`. (RDB)


0.7.0
-----

Contributors (0.7.0):

- Jake Moss (JM)
- Giacomo Pope (GP)
- Joris Roos (JR)
- Edgar Costa (EC)
- Frédéric Chapoton (FC)
- Oscar Benjamin (OB)
- Tom Hubrecht (TH)

Highlights (0.7.0):

- [gh-270](https://github.com/flintlib/python-flint/pull/270),
  PyPI packages are now built with FLINT 3.2.0 (previously
  3.0.1 was used). All versions from FLINT 3.0.0 to FLINT 3.2.0
  are compatible with python-flint but some features require
  newer FLINT versions and the PyPI packages now use FLINT 3.2.0.
- [gh-97](https://github.com/flintlib/python-flint/pull/97),
  [gh-182](https://github.com/flintlib/python-flint/pull/180):
  Add `fq_default` and `fq_default_poly` for finite fields and
  univariate polynomials over finite fields. This exposes all
  of the different implementations of finite fields (`fq_zech`,
  `fq_nmod` etc) via the `fq_default` interface. (GP)
- [gh-132](https://github.com/flintlib/python-flint/pull/132),
  [gh-164](https://github.com/flintlib/python-flint/pull/164),
  [gh-190](https://github.com/flintlib/python-flint/pull/190),
  [gh-191](https://github.com/flintlib/python-flint/pull/191):
  [gh-192](https://github.com/flintlib/python-flint/pull/192):
  [gh-216](https://github.com/flintlib/python-flint/pull/216):
  [gh-225](https://github.com/flintlib/python-flint/pull/225):
  [gh-228](https://github.com/flintlib/python-flint/pull/228):
  Add `fmpz_mpoly`, `fmpq_mpoly`, `nmod_poly` and `fmpz_mod_poly`
  types for multivariate polynomials with integer, rational or
  integers mod `n` coefficients. (JM)
- [gh-142](https://github.com/flintlib/python-flint/pull/142)
  Add `acb_theta` module for the numerical evaluation of [theta
  functions](https://flintlib.org/doc/acb_theta.html) (only
  available for `Flint >= 3.1`). (EC)
- [gh-218](https://github.com/flintlib/python-flint/pull/218)
  [gh-254](https://github.com/flintlib/python-flint/pull/254)
  [gh-255](https://github.com/flintlib/python-flint/pull/255)
  An experimental interface for FLINT's generic rings has been
  added. This provides access to many of FLINT's types that
  are not yet wrapped by python-flint such as Gaussian integer,
  number fields, qqbar, calcium, as well as both univariate and
  multivariate polynomials and series over these rings (no
  matrices yet though). (OB and TH)
- [gh-129](https://github.com/flintlib/python-flint/pull/129)
  [gh-208](https://github.com/flintlib/python-flint/pull/208)
  Use meson/meson-python instead of setuptools as the build system
  for parallel builds and better detection of build and dependency
  requirements. (OB)
- [gh-201](https://github.com/flintlib/python-flint/pull/201)
  [gh-202](https://github.com/flintlib/python-flint/pull/202)
  The documentation has been updated and is now at
  [readthedocs](https://python-flint.readthedocs.io/en/latest/).
  (OB)
  [gh-235](https://github.com/flintlib/python-flint/pull/235)
  Nightly wheels for python-flint can now be installed from the
  [Anaconda Scientific Python Nightly Wheels index]
  (https://anaconda.org/scientific-python-nightly-wheels/python-flint).
  [gh-259](https://github.com/flintlib/python-flint/pull/259)
  Add PyPI wheels for Linux aarch64 (Linux on ARM CPU). (OB)

Compatibility break (0.7.0):

- [gh-189](https://github.com/flintlib/python-flint/pull/189)
  As of python-flint 0.7.0 `fmpq_poly.factor()` now returns
  primitive rather than monic factors i.e. `2*x + 1` rather than
  `x + 1/2`. This ensures consistency between all poly types
  including between `fmpq_poly` and `fmpq_mpoly`. (OB)

Other changes (0.7.0):

- [gh-269](https://github.com/flintlib/python-flint/pull/269)
  All univariate and multivariate polynomial types have
  `is_zero`, `is_one` and `is_constant` methods. All polynomial
  types now consistently handle negative powers where possible.
- [gh-261](https://github.com/flintlib/python-flint/pull/261)
  Add `fmpz_mat.fflu` for fraction-free LU decomposition of
  an integer matrix.
- [gh-251](https://github.com/flintlib/python-flint/pull/251)
  Add mpmath-style precision context managers for arb
  `extraprec`, `extradps`, `workprec` and `workdps`. (TH)
- [gh-250](https://github.com/flintlib/python-flint/pull/250)
  Add `fmpq.gcd()` method.
- [gh-215](https://github.com/flintlib/python-flint/pull/215)
  [gh-219](https://github.com/flintlib/python-flint/pull/219)
  The FLINT binding declarations are now fully generated
  automatically from the FLINT docs. (OB)
- [gh-203](https://github.com/flintlib/python-flint/pull/203)
  [gh-204](https://github.com/flintlib/python-flint/pull/204)
  [gh-205](https://github.com/flintlib/python-flint/pull/205)
  [gh-206](https://github.com/flintlib/python-flint/pull/206)
  [gh-207](https://github.com/flintlib/python-flint/pull/207)
  [gh-211](https://github.com/flintlib/python-flint/pull/211)
  [gh-212](https://github.com/flintlib/python-flint/pull/212)
  [gh-271](https://github.com/flintlib/python-flint/pull/271)
  Various linting fixes and codebase improvements (FC and GP).
- [gh-189](https://github.com/flintlib/python-flint/pull/189)
  All scalar and poly types now have `sqrt`. All poly types now
  have `factor_squarefree` and `leading_coefficient` methods.
  Exception types raised in a number of places were changed to
  `DomainError` for better consistency. (OB)
- [gh-196](https://github.com/flintlib/python-flint/pull/196)
  Supported Python versions are 3.10-3.13 (3.9 dropped). CI
  Testing added for 3.13 free-threaded CPython.
- [gh-194](https://github.com/flintlib/python-flint/pull/194)
  Add version checking for build requirements. (OB)
- [gh-180](https://github.com/flintlib/python-flint/pull/180)
  Add `equal_trunc`, `add_trunc`, `sub_trunc`, `mul_low`,
  `mul_mod` and `pow_trunc` methods to `fmpz_mod_poly`. (GP)
- [gh-177](https://github.com/flintlib/python-flint/pull/177)
  Remove old Py2 code for compatibility with Cython 3.1. (OB)
- [gh-176](https://github.com/flintlib/python-flint/pull/176)
  Fix the error messages from `fmpq` constructor. (OB)
- [gh-174](https://github.com/flintlib/python-flint/pull/174)
  Add `pow_mod` and `compose_mod` methods to `nmod_poly` and
  `fmpz_mod_poly`. Also add some missing methods to `nmod_poly`
  that other poly types already have. (GP)
- [gh-172](https://github.com/flintlib/python-flint/pull/172)
  Add `fmpz_is_square`. (JR)
- [gh-168](https://github.com/flintlib/python-flint/pull/168)
  Make comparisons consistent between different types. Add
  `is_one` and `is_zero` for all poly types. (OB)
- [gh-161](https://github.com/flintlib/python-flint/pull/161)
  Add `acb.lerch_phi` to compute the Lerch transcendent. (OB)
- [gh-160](https://github.com/flintlib/python-flint/pull/160)
  Add `bits` to `arb` and `acb`, add `log_base` to `arb`. (JR)
- [gh-148](https://github.com/flintlib/python-flint/pull/148)
  Remove debug symbols to make smaller Linux binaries. (OB)
- [gh-144](https://github.com/flintlib/python-flint/pull/144)
  Add `rel_one_accuracy_bits` to `arb` and `acb`. (EC)
- [gh-137](https://github.com/flintlib/python-flint/pull/137)
  Add `erfinv` and `erfcinv` for `arb`. (JR)
- [gh-119](https://github.com/flintlib/python-flint/pull/119)
  Add compatibility with Flint 3.1. (OB)

0.6.0
-----

- [gh-112](https://github.com/flintlib/python-flint/issues/112),
  [gh-111](https://github.com/flintlib/python-flint/issues/111),
  [gh-110](https://github.com/flintlib/python-flint/issues/110),
  [gh-108](https://github.com/flintlib/python-flint/issues/108):
  Add pyproject.toml and build dependencies. This means that
  python-flint can be built from source without
  `--no-build-isolation`.
- [gh-109](https://github.com/flintlib/python-flint/issues/109):
  Use exact division for non-field domains. Now `fmpz(6)/fmpz(3)`
  returns an exact result `fmpz(2)` or raises an error if an exact
  result is not possible. Similar changes for `fmpz_poly/fmpz`,
  `fmpz_mat/fmpz`, and for polynomial division with `fmpz_poly`,
  `fmpq_poly`, `nmod_poly` and `fmpz_mod_poly`.
- [gh-106](https://github.com/flintlib/python-flint/issues/106):
  Add `fmpz_mod_mat` for matrices of integers mod `n` where `n` is
  larger than word sized.
- [gh-104](https://github.com/flintlib/python-flint/issues/104):
  Bump Flint from 3.0.0 to 3.0.1

0.5.0
-----

Important compatibility changes:

- [gh-80](https://github.com/flintlib/python-flint/issues/80),
  [gh-94](https://github.com/flintlib/python-flint/issues/94),
  [gh-98](https://github.com/flintlib/python-flint/issues/98):
  Switch from Flint 2.9 to Flint 3.
- [gh-100](https://github.com/flintlib/python-flint/issues/100):
  Supports Python 3.12 by using setuptools instead of
  numpy.distutils.

New features:

- [gh-87](https://github.com/flintlib/python-flint/issues/87):
  Adds `fmpz_mod_poly` type for polynomials over `fmpz_mod`.
- [gh-85](https://github.com/flintlib/python-flint/issues/85):
  Adds discrete logarithms to `fmpz_mod`.
- [gh-83](https://github.com/flintlib/python-flint/issues/83):
  Introduces the `fmpz_mod` type for multi-precision integer mods.

Bug fixes:

- [gh-93](https://github.com/flintlib/python-flint/issues/93):
  Fixes a bug with `pow(int, int, fmpz)` which previously gave
  incorrect results.
- [gh-78](https://github.com/flintlib/python-flint/issues/78),
  [gh-79](https://github.com/flintlib/python-flint/issues/79):
  minor fixes for the `nmod` type.

0.4.4
-----

- [gh-75](https://github.com/flintlib/python-flint/issues/75),
  [gh-77](https://github.com/flintlib/python-flint/issues/77):
  finish bulk of the work in refactoring `python-flint` into
  submodules
- [gh-72](https://github.com/flintlib/python-flint/issues/72):
  The roots method of `arb_poly` is not supported. Use either the
  `complex_roots` method or `acb_roots(p).roots()` to get the old
  behaviour of returning the complex roots. The `roots` method on
  `fmpz_poly` and `fmpq_poly` now return integer and rational
  roots respectively. To access complex roots on these types, use
  the `complex_roots` method. For `acb_poly`, both `roots` and
  `complex_roots` behave the same
- [gh-71](https://github.com/flintlib/python-flint/issues/71):
  Include files in sdist and fix issue
  [gh-70](https://github.com/flintlib/python-flint/issues/70)
- [gh-67](https://github.com/flintlib/python-flint/issues/67):
  Continue refactoring job to introduce submodules into `python-flint`

0.4.3
-----

- [gh-63](https://github.com/flintlib/python-flint/issues/63):
  The `roots` method of `arb_poly`, and `nmod_poly` is no longer
  supported. Use `acb_roots(p).roots()` to get the old behaviour
  of returning the roots as `acb`. Note that the `roots` method of
  `fmpz_poly` and `fmpq_poly` currently returns the complex roots
  of the polynomial.
- [gh-61](https://github.com/flintlib/python-flint/issues/61):
  Start refactoring job to introduce submodules into `python-flint`

0.4.2
-----

- [gh-57](https://github.com/flintlib/python-flint/issues/57):
  Adds manylinux wheels

0.4.1
-----

- [gh-47](https://github.com/flintlib/python-flint/issues/47):
  Removes Linux wheels, updates instructions for building from
  source.

0.4.0
-----

- [gh-45](https://github.com/flintlib/python-flint/issues/45):
  Adds wheels for Windows, OSX and manylinux but the Linux wheels
  are broken.

License
------------

Python-FLINT is licensed MIT. FLINT and Arb are LGPL v2.1+.
