Python-FLINT

https://python-flint.readthedocs.io/en/latest/
Admin
Python-FLINT is a Python extension module wrapping FLINT and Arb libraries, providing support for...
Tokens:361,456
Snippets:3,193
Trust Score:8.3
Update:11 hours ago
Show doc for...
Tokens:
Raw
### Install python-flint in editable mode with meson-python

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

Clone the repository, install build dependencies, and perform an editable install with --no-build-isolation. This setup allows changes to python-flint source to be reflected in the environment without reinstalling, and triggers a rebuild on each new Python process.

```bash
git clone https://github.com/flintlib/python-flint.git
cd python-flint
pip install meson meson-python cython ninja
pip install --no-build-isolation --editable .
python -m flint.test  # recommended if you have made changes
```

--------------------------------

### inflate method example

Source: https://python-flint.readthedocs.io/en/latest/fmpz_poly.html

Computes the inflation of a polynomial p(x) to q(x) = p(x^n). The example shows inflating f(x) = x + 1 by n=2 to get x^2 + 1.

```python
>>> f = fmpz_poly([1, 1])
>>> f.inflate(2)
x^2 + 1
```

--------------------------------

### Setup and configure a build directory

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Expected workflow: call meson setup once per build directory, then use meson configure to change options. This keeps the initial setup and subsequent configuration separate.

```bash
meson setup build
meson configure build -Dsome_option=true -Dsome_other_option=false
```

--------------------------------

### Build and install a typical Meson project

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Standard Meson commands to create a build directory, compile the project, and install it. These are analogous to the autotools commands ./configure, make, and make install.

```shell
meson setup build
meson compile -C build
meson install -C build
```

--------------------------------

### Example output of python-flint test suite

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

Expected output when running the test suite with --quiet, showing all tests and doctests passing.

```bash
$ python -m flint.test --quiet
Running tests...
Running doctests...
flint.test: all 54 tests passed!
flint.test: all 4283 doctests passed!
----------------------------------------
OK: Your installation of python-flint seems to be working just fine!
```

--------------------------------

### Equivalent test command after installation

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Shows the equivalent of installing python-flint and then running the same test command.

```bash
pip install .
python -m flint.test
```

--------------------------------

### Recommended build setup with meson and spin

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Recommended approach because spin build does not always configure the project correctly. Run meson setup first, then spin build.

```bash
meson setup build -Dflint_version_check=false
spin build
```

--------------------------------

### Build and install python-flint from local source

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

Build and install python-flint from a local source directory or archive using pip. After installation, run the tests as described in 'Testing your installation'.

```bash
pip install path/to/python-flint-directory-or-archive
```

--------------------------------

### Compile python-flint with meson compile

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Builds python-flint after a successful meson setup. Run this after 'meson setup build'.

```bash
meson compile -C build
```

--------------------------------

### Install Meson project into local directory

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

For Python projects using Meson, install the project into a local build-install directory instead of a system-wide location. The --only-changed flag and --destdir option are used to avoid a full install.

```shell
meson install --only-changed -C build --destdir ../build-install
```

--------------------------------

### Install Python development dependencies

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Installs the development dependencies listed in requirements-dev.txt, including cython and meson, into the activated virtual environment.

```bash
pip install -r requirements-dev.txt
```

--------------------------------

### Create multiple build directories with meson setup

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Shows how to create separate build directories for debug and release configurations using meson setup. Each build directory retains its own configuration, and subsequent commands must specify the build directory with -C.

```bash
meson setup build-debug -Dbuildtype=debug
meson setup build-release -Dbuildtype=release
```

--------------------------------

### Re-running meson setup on an already configured directory

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Running meson setup again on an existing build directory works but produces a warning that the directory is already configured. The output shows the message and suggests using --reconfigure or --wipe if needed.

```bash
$ meson setup build --pkg-config-path=.local/lib/pkgconfig -Dadd_flint_rpath=true -Dbuildtype=debug
Directory already configured.

Just run your build command (e.g. ninja) and Meson will regenerate as necessary.
Run "meson setup --reconfigure to force Meson to regenerate.

If build failures persist, run "meson setup --wipe" to rebuild from scratch
using the same options as passed when configuring the build.
```

--------------------------------

### Install GMP and MPFR on Ubuntu

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

If FLINT cannot be installed from a package manager, install GMP and MPFR first, e.g., on Ubuntu.

```bash
sudo apt-get install libgmp-dev libmpfr-dev
```

--------------------------------

### Clean build directory with --wipe

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Instead of make clean, delete the build directory or use meson setup --wipe to remove built files while preserving configuration options. The ellipsis indicates other commands between setup and wipe.

```bash
meson setup build -Doption=true
...
meson setup build --wipe  # deletes all built files, option is still true
```

--------------------------------

### Install FLINT from git using script

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

Use the bin/install_flint_ubuntu.sh script to install all dependencies and build FLINT from a specified git ref.

```bash
bin/install_flint_ubuntu.sh v3.0.1  # version 3.0.1
bin/install_flint_ubuntu.sh main    # latest git
```

--------------------------------

### Build a wheel with pypa/build

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

Builds a wheel using the pypa/build tool. Requires pypa/build to be installed first (pip install build). Wheels built this way do not include dependencies and cannot generally be installed on other systems.

```bash
python -m build
```

--------------------------------

### Install from git master

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

Builds and installs the latest python-flint from the master branch of the GitHub repository.

```bash
pip install git+https://github.com/flintlib/python-flint.git@master
```

--------------------------------

### Install python-flint from PyPI with pip

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

Downloads, builds, and installs the latest release of python-flint into the active Python environment. This command tries to install a binary first but falls back to building from source if no binary is available.

```bash
pip install python-flint
```

--------------------------------

### Install from local source directory

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

Builds and installs python-flint from a local source checkout. Run this command from the root of the source directory.

```bash
pip install .
```

--------------------------------

### fmpq_poly resultant example

Source: https://python-flint.readthedocs.io/en/latest/fmpq_poly.html

Shows the resultant method for rational polynomials. The examples include cases with zero resultant and non-zero resultants, including a large polynomial example.

```python
>>> A = fmpq_poly([1, 0, -1]); B = fmpq_poly([1, -1])
>>> A.resultant(B)
0
>>> C = fmpq_poly([1, 0, 0, 0, 0, -1, 1])
>>> D = fmpq_poly([1, 0, 0, -1, 0, 0, 1])
>>> C.resultant(D)
3
>>> f = fmpq_poly([1, -1] + [0] * 98 + [1])
>>> g = fmpq_poly([1] + [0] * 50 + [-1] + [0] * 48 + [1])
>>> f.resultant(g)
1125899906842623
```

--------------------------------

### Persistent options in repeated meson setup calls

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Configuration options passed to meson setup are persistent and combined in repeated calls. The second call adds a new option while keeping the first option still active.

```bash
meson setup build -Dfirst_option=true
meson setup build -Dsecond_option=false  # first_option is still true
```

--------------------------------

### fmpq_poly sqrt example

Source: https://python-flint.readthedocs.io/en/latest/fmpq_poly.html

Demonstrates the sqrt method, which returns the exact square root of the polynomial or None if it is not a perfect square. The example shows a polynomial that is a perfect square.

```python
>>> p = fmpq_poly([1,2,1],4)
>>> p
1/4*x^2 + 1/2*x + 1/4
>>> p.sqrt()
1/2*x + 1/2
```

--------------------------------

### Set PKG_CONFIG_PATH for FLINT dependencies

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

Set the PKG_CONFIG_PATH environment variable to point to the directory containing the .pc files for FLINT, GMP, and MPFR when they are installed in a non-standard location. This is needed for the meson build system (python-flint 0.7.0+) to find the dependencies at build time. The example assumes FLINT is installed in ~/.local.

```bash
export PKG_CONFIG_PATH=$(pwd)/.local/lib/pkgconfig
```

--------------------------------

### Install specific python-flint version

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

Installs a specific version of python-flint from PyPI. Replace 0.7.0a4 with the desired version.

```bash
pip install python-flint==0.7.0a4
```

--------------------------------

### factor_squarefree() example

Source: https://python-flint.readthedocs.io/en/latest/fmpq_poly.html

Factors into square-free polynomials. Example shows p, its factor_squarefree, and factor for comparison.

```python
>>> x = fmpq_poly([0, 1])
>>> p = x**2 * (x/2 - 1)**2 * (x + 1)**3
>>> p
1/4*x^7 + (-1/4)*x^6 + (-5/4)*x^5 + 1/4*x^4 + 2*x^3 + x^2
>>> p.factor_squarefree()
(1/4, [(x^2 + (-2)*x, 2), (x + 1, 3)])
>>> p.factor()
(1/4, [(x, 2), (x + (-2), 2), (x + 1, 3)])
```

--------------------------------

### factor() default and monic examples

Source: https://python-flint.readthedocs.io/en/latest/fmpq_poly.html

Factors into irreducibles. Default returns primitive denominator-free factors; monic=True returns monic factors. Examples show both for legendre_p(5) and a product.

```python
>>> fmpq_poly.legendre_p(5).factor()
(1/8, [(x, 1), (63*x^4 + (-70)*x^2 + 15, 1)])
>>> (fmpq_poly([1,-1],10) ** 5 * fmpq_poly([1,2,3],7)).factor()
(-1/700000, [(3*x^2 + 2*x + 1, 1), (x + (-1), 5)])
```

```python
>>> fmpq_poly.legendre_p(5).factor(monic=True)
(63/8, [(x, 1), (x^4 + (-10/9)*x^2 + 5/21, 1)])
>>> (fmpq_poly([1,-1],10) ** 5 * fmpq_poly([1,2,3],7)).factor(monic=True)
(-3/700000, [(x^2 + 2/3*x + 1/3, 1), (x + (-1), 5)])
```

--------------------------------

### acb.zeta_zeros static method example

Source: https://python-flint.readthedocs.io/en/latest/acb.html

Returns num consecutive nontrivial zeros of the Riemann zeta function starting at index n. The example prints 10 zeros starting at index 1000 with 10 decimal places and no radius.

```python
>>> for r in acb.zeta_zeros(1000, 10):
...     print(r.str(10, radius=False))
...
0.5000000000 + 1419.422481j
0.5000000000 + 1420.416526j
0.5000000000 + 1421.850567j
0.5000000000 + 1422.461311j
0.5000000000 + 1424.463046j
0.5000000000 + 1425.873469j
0.5000000000 + 1426.645980j
0.5000000000 + 1427.365671j
0.5000000000 + 1428.592306j
0.5000000000 + 1429.650477j
```

--------------------------------

### Get number of variables in context

Source: https://python-flint.readthedocs.io/en/latest/fmpq_mpoly.html

Shows how to get the number of variables using nvars. The example uses fmpq_mpoly_ctx with lex ordering and prints the count.

```python
>>> ctx = fmpq_mpoly_ctx.get(('x', 4), 'lex')
>>> ctx.nvars()
4
```

--------------------------------

### Install FLINT on macOS with Homebrew

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

On macOS, install FLINT from Homebrew. Ensure the version is at least 3.0.

```bash
brew install flint
```

--------------------------------

### Editable install with custom pkg-config path

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

Use this command when FLINT is installed in a non-standard location. Set the pkg-config path via --config-settings to point to the correct .pc files.

```bash
pip install
    --no-build-isolation \
    --config-settings=setup-args="--pkg-config-path=$(pwd)/.local/lib/pkgconfig" \
    --editable .
```

--------------------------------

### complex_roots() example

Source: https://python-flint.readthedocs.io/en/latest/fmpq_poly.html

Computes complex roots of the polynomial. Requires setting ctx.prec; example shows root with error bounds.

```python
>>> from flint import fmpq, ctx
>>> ctx.prec = 53
>>> fmpq_poly([fmpq(2,3),1]).complex_roots()
[([-0.666666666666667 +/- 3.34e-16], 1)]
```

--------------------------------

### Install FLINT and python-flint from source on Ubuntu 24.04

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

Two-step build for python-flint >= 0.7.0 on Ubuntu 24.04: install FLINT 3.0.1 system-wide with apt, then build and install the latest release from PyPI using pip with --no-binary. pip creates an isolated build environment and installs build dependencies (Cython, meson) automatically.

```bash
sudo apt-get install libflint-dev
```

```bash
pip install --no-binary python-flint python-flint
```

--------------------------------

### minpoly() example

Source: https://python-flint.readthedocs.io/en/latest/nmod_mat.html

Computes the minimal polynomial of a matrix. The example also shows the characteristic polynomial for comparison.

```python
>>> from flint import nmod_mat
>>> M = nmod_mat([[2, 1, 0], [0, 2, 0], [0, 0, 2]], 7)
>>> M.charpoly()
x^3 + x^2 + 5*x + 6
>>> M.minpoly()
x^2 + 3*x + 4
```

--------------------------------

### Configure the build with meson setup

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Configures the build in the 'build' directory. Checks for system dependencies such as FLINT, GMP, MPFR, a C compiler, and Cython.

```bash
meson setup build
```

--------------------------------

### Get term order of context

Source: https://python-flint.readthedocs.io/en/latest/fmpq_mpoly.html

Shows how to get the term order using ordering. The example uses fmpq_mpoly_ctx with deglex ordering and prints the Ordering enum.

```python
>>> ctx = fmpq_mpoly_ctx.get(('w', 4), 'deglex')
>>> ctx.ordering()
<Ordering.deglex: 'deglex'>
```

--------------------------------

### discriminant() examples

Source: https://python-flint.readthedocs.io/en/latest/fmpq_poly.html

Returns the discriminant of the polynomial. Examples show integer and rational results.

```python
>>> f = fmpq_poly([1, 2, 3, 4, 5, 6])
>>> f.discriminant()
1037232
>>> f = fmpq_poly([1, 3, 5, 7, 9, 11, 13])
>>> f.discriminant()
-2238305839
>>> f = fmpq_poly([1, 3, 5, 7, 9, 11, 13], 10)
>>> f.discriminant()
-2238305839/10000000000
```

--------------------------------

### inv() example

Source: https://python-flint.readthedocs.io/en/latest/nmod_mat.html

Returns the inverse of a matrix. The example creates a 2x2 matrix with modulus 17 and prints the inverse.

```python
>>> from flint import nmod_mat
>>> A = nmod_mat(2,2,[1,2,3,4],17)
>>> A.inv()
[15, 1]
[10, 8]
```

--------------------------------

### Get degree of polynomial

Source: https://python-flint.readthedocs.io/en/latest/fq_default_poly.html

Returns the degree of the polynomial. The example uses p=163.

```python
>>> R = fq_default_poly_ctx(163)
>>> f = R([1,2,3])
>>> f.degree()
2
```

--------------------------------

### Build with spin build and equivalent meson commands

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Uses spin build to set up and build the project in one step, passing -Dflint_version_check=false to meson setup. The commented lines show the equivalent meson commands.

```bash
spin build -- -Dflint_version_check=false

# Equivalent to:

meson setup build -Dflint_version_check=false
meson compile -C build
meson install --only-changed -C build --destdir ../build-install
```

--------------------------------

### fmpq_poly right_shift example

Source: https://python-flint.readthedocs.io/en/latest/fmpq_poly.html

Illustrates the right_shift method, which shifts the polynomial right by a given number of coefficients, equivalent to floor division by x^n. The example shows shifts of 0, 1, and 4.

```python
>>> f = fmpq_poly([1,2,3])
>>> f.right_shift(0)
3*x^2 + 2*x + 1
>>> f.right_shift(1)
3*x + 2
>>> f.right_shift(4)
0
```

--------------------------------

### transpose() example

Source: https://python-flint.readthedocs.io/en/latest/nmod_mat.html

Returns the transpose of a matrix. The example creates a 2x3 matrix with modulus 7 and prints its transpose.

```python
>>> nmod_mat(2,3,range(6),7).transpose()
[0, 3]
[1, 4]
[2, 5]
```

--------------------------------

### gcd() example

Source: https://python-flint.readthedocs.io/en/latest/fmpq_poly.html

Returns the greatest common divisor of two polynomials. Example shows gcd of a product and one factor.

```python
>>> A = fmpq_poly([1,2,6],6); B = fmpq_poly([4,2,1],12)
>>> (A * B).gcd(B)
x^2 + 2*x + 4
```

--------------------------------

### Get constant coefficient of polynomial

Source: https://python-flint.readthedocs.io/en/latest/fq_default_poly.html

Returns the constant coefficient of the polynomial. The example uses p=163 and d=3.

```python
>>> R = fq_default_poly_ctx(163, 3)
>>> f = R([1,2,3])
>>> f.constant_coefficient()
1
```

--------------------------------

### left_shift() examples

Source: https://python-flint.readthedocs.io/en/latest/fmpq_poly.html

Shifts polynomial left by n coefficients, equivalent to multiplying by x^n. Examples show shifts of 0, 1, and 4.

```python
>>> f = fmpq_poly([1,2,3])
>>> f.left_shift(0)
3*x^2 + 2*x + 1
>>> f.left_shift(1)
3*x^3 + 2*x^2 + x
>>> f.left_shift(4)
3*x^6 + 2*x^5 + x^4
```

--------------------------------

### Get generator of polynomial ring

Source: https://python-flint.readthedocs.io/en/latest/fq_default_poly.html

Returns the generator of the polynomial ring, which is x. The example uses p=163.

```python
>>> R = fq_default_poly_ctx(163)
>>> R.gen()
x
```

--------------------------------

### Get characteristic of field

Source: https://python-flint.readthedocs.io/en/latest/fq_default_poly.html

Returns the characteristic of the field as an fmpz type. The example uses p=65537 and d=3.

```python
>>> R = fq_default_poly_ctx(65537, 3)
>>> R.characteristic()
65537
```

--------------------------------

### Build in release mode (meson setup build -Dbuildtype=release)

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Configures a release build with full compiler optimizations for the C code generated from Cython. This is recommended for performance measurements. Building in release mode takes longer than debug mode. The setting is persistent and must be explicitly disabled when no longer needed.

```bash
meson setup build -Dbuildtype=release
```

--------------------------------

### length: Get polynomial length

Source: https://python-flint.readthedocs.io/en/latest/fq_default_poly.html

Returns the length of the polynomial. Example uses fq_default_poly_ctx(163) and polynomial [1,2,3].

```python
>>> R = fq_default_poly_ctx(163)
>>> f = R([1,2,3])
>>> f.length()
3
```

--------------------------------

### Build GMP, MPFR, and FLINT from source

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

If the whole stack must be built from source, download and build each with the standard configure, make, make install sequence.

```bash
./configure
make
make install
```

--------------------------------

### Get coefficients of a polynomial with fmpz_poly.coeffs()

Source: https://python-flint.readthedocs.io/en/latest/acb_poly.html

Returns the coefficients of the polynomial as a list. Example uses fmpz_poly with coefficients [1,2,3,4,5].

```python
>>> from flint import fmpz_poly
>>> f = fmpz_poly([1,2,3,4,5])
>>> f.coeffs()
[1, 2, 3, 4, 5]
```

--------------------------------

### Display global context settings

Source: https://python-flint.readthedocs.io/en/latest/general.html

Printing `flint.ctx` in the REPL shows current settings like precision, cap, and threads with explanations.

```python
>>> from flint import ctx
>>> ctx
pretty = True      # pretty-print repr() output
unicode = False    # use unicode characters in output
prec = 53          # real/complex precision (in bits)
dps = 15           # real/complex precision (in digits)
cap = 10           # power series precision
threads = 1        # max number of threads used internally
```

--------------------------------

### leading_coefficient: Get leading coefficient

Source: https://python-flint.readthedocs.io/en/latest/fq_default_poly.html

Returns the leading coefficient of the polynomial. Example uses fq_default_poly_ctx(163) and polynomial [1,2,3].

```python
>>> R = fq_default_poly_ctx(163)
>>> f = R([1,2,3])
>>> f.leading_coefficient()
3
```

--------------------------------

### Run python-flint tests from local build

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Change to the local build's site-packages directory and run the python-flint test suite using the local build. This requires the build-install directory to be present.

```shell
cd build-install/usr/lib/python3.12/site-packages
python -m flint.test
```

--------------------------------

### Get zero element of polynomial ring

Source: https://python-flint.readthedocs.io/en/latest/fq_default_poly.html

Returns the additive identity (zero) of the polynomial ring. The example uses p=163.

```python
>>> R = fq_default_poly_ctx(163)
>>> R.zero()
0
```

--------------------------------

### Get one element of polynomial ring

Source: https://python-flint.readthedocs.io/en/latest/fq_default_poly.html

Returns the multiplicative identity (one) of the polynomial ring. The example uses p=163.

```python
>>> R = fq_default_poly_ctx(163)
>>> R.one()
1
```

--------------------------------

### Get term order (fmpz_mpoly_ctx.ordering)

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mpoly.html

Returns the term order of the context object. The example shows the output for a deglex ordering.

```python
>>> ctx = fmpz_mpoly_ctx.get(('w', 4), 'deglex')
>>> ctx.ordering()
<Ordering.deglex: 'deglex'>
```

--------------------------------

### Configure meson for non-standard dependency locations

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Tells meson to look for pkg-config files (e.g., flint.pc) in /some/dir/lib/pkgconfig and adds /some/dir/lib to the runtime library search path. The add_flint_rpath option may not be needed depending on your OS.

```bash
meson setup build \
    --pkg-config-path=/some/dir/lib/pkgconfig \
    -Dadd_flint_rpath=true
```

--------------------------------

### Get all coefficients (fmpz_mpoly.coeffs)

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mpoly.html

Returns the coefficients of each term as a list of fmpz. The example shows the order of coefficients for a polynomial with four terms.

```python
>>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex')
>>> f = ctx.from_dict({(0, 0): 1, (1, 0): 2, (0, 1): 3, (1, 1): 4})
>>> f.coeffs()
[4, 2, 3, 1]
```

--------------------------------

### Get coefficient by index (fmpz_mpoly.coefficient)

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mpoly.html

Returns the coefficient at the given index. The example creates a polynomial and retrieves the coefficient at index 1.

```python
>>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex')
>>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3})
>>> p.coefficient(1)
2
```

--------------------------------

### Get number of variables (fmpz_mpoly_ctx.nvars)

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mpoly.html

Returns the number of variables in the context. The example creates a context with four variables and prints the count.

```python
>>> ctx = fmpz_mpoly_ctx.get(('x', 4), 'lex')
>>> ctx.nvars()
4
```

--------------------------------

### Get polynomial degree with degree()

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mod_poly.html

Returns the degree of the polynomial. The example uses modulus 163 and a polynomial of degree 2.

```python
>>> R = fmpz_mod_poly_ctx(163)
>>> f = R([1,2,3])
>>> f.degree()
2
```

--------------------------------

### Run tests with spin

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Use the spin frontend to run the python-flint tests. It rebuilds the project if necessary and runs the tests using the local build.

```shell
spin test
```

--------------------------------

### Get constant coefficient with constant_coefficient()

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mod_poly.html

Returns the constant coefficient of the polynomial as an fmpz_mod value. The example uses modulus 163.

```python
>>> R = fmpz_mod_poly_ctx(163)
>>> f = R([1,2,3])
>>> f.constant_coefficient()
fmpz_mod(1, 163)
```

--------------------------------

### Get numerator of rational number

Source: https://python-flint.readthedocs.io/en/latest/_gr.html

Returns the numerator of a rational number in the rational context. The example creates 2/3 and retrieves its numerator.

```python
>>> from flint.types._gr import gr_fmpq_ctx as Q
>>> q = Q(2) / 3
>>> q
2/3
>>> q.numer()
2
```

--------------------------------

### View and change configuration with meson configure

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Use meson configure to view or modify the configuration of an existing build directory. The -D option sets or changes a configuration option.

```bash
meson configure build-debug  # view the configuration
meson configure build-debug -Dsome_option=true  # change the configuration
```

--------------------------------

### Get denominator of rational number

Source: https://python-flint.readthedocs.io/en/latest/_gr.html

Returns the denominator of a rational number in the rational context. The example creates 2/3 and retrieves its denominator.

```python
>>> from flint.types._gr import gr_fmpq_ctx as Q
>>> q = Q(2) / 3
>>> q
2/3
>>> q.denom()
3
```

--------------------------------

### Get base field of polynomial ring

Source: https://python-flint.readthedocs.io/en/latest/fq_default_poly.html

Returns the base field of the polynomial ring as an fq_default_ctx object. The example uses p=65537 and d=3.

```python
>>> R = fq_default_poly_ctx(65537, 3)
>>> R.base_field()
fq_default_ctx(65537, 3, 'z', x^3 + 3*x^2 + 30077, 'FQ_NMOD')
```

--------------------------------

### Get context of fmpq_mpoly

Source: https://python-flint.readthedocs.io/en/latest/fmpq_mpoly.html

Returns the context object for the polynomial. The example verifies that the returned context is the same object used to create the polynomial.

```python
>>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex')
>>> p = ctx.from_dict({(0, 1): 2})
>>> ctx is p.context()
True
```

--------------------------------

### fmpz.partitions_p examples

Source: https://python-flint.readthedocs.io/en/latest/fmpz.html

Returns p(n), the number of partitions of n, as an fmpz. The partition function grows rapidly; on 32-bit systems n must not exceed about 10^16, on 64-bit about 10^20. For large n, setting ctx.threads = 2 on multicore systems helps.

```python
>>> [fmpz(n).partitions_p() for n in range(8)]
[1, 1, 2, 3, 5, 7, 11, 15]
>>> fmpz(100).partitions_p()
190569292
>>> len(str(fmpz(10**9).partitions_p()))
35219
```

--------------------------------

### Get zero element with zero()

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mod_poly.html

Returns the zero element of the polynomial ring. The example creates a context with modulus 163 and calls zero().

```python
>>> R = fmpz_mod_poly_ctx(163)
>>> R.zero()
0
```

--------------------------------

### Get one element with one()

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mod_poly.html

Returns the one element of the polynomial ring. The example creates a context with modulus 163 and calls one().

```python
>>> R = fmpz_mod_poly_ctx(163)
>>> R.one()
1
```

--------------------------------

### Get modulus as fmpz with modulus()

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mod_poly.html

Returns the modulus from the context as an fmpz type. The example shows the modulus value for 2**127 - 1.

```python
>>> R = fmpz_mod_poly_ctx(2**127 - 1)
>>> R.modulus()
170141183460469231731687303715884105727
```

--------------------------------

### monoms – Get exponent vectors of all terms

Source: https://python-flint.readthedocs.io/en/latest/nmod_mpoly.html

Returns the exponent vectors of each term as a tuple of fmpz. The example shows the monomials in the order they appear in the polynomial.

```python
>>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex')
>>> f = ctx.from_dict({(0, 0): 1, (1, 0): 2, (0, 1): 3, (1, 1): 4})
>>> f.monoms()
[(1, 1), (1, 0), (0, 1), (0, 0)]
```

--------------------------------

### Create fmpq_mpoly from dictionary

Source: https://python-flint.readthedocs.io/en/latest/fmpq_mpoly.html

Shows how to create a polynomial from a dictionary mapping exponent tuples to coefficients. The example uses fmpq_mpoly_ctx with lex ordering and prints the resulting polynomial.

```python
>>> ctx = fmpq_mpoly_ctx.get(('x', 'y'), 'lex')
>>> ctx.from_dict({(1,0):2, (1,1):3, (0,1):1})
3*x*y + 2*x + y
```

--------------------------------

### Get parent context of element

Source: https://python-flint.readthedocs.io/en/latest/_gr.html

Returns the parent context of an element. The example creates an element in a gr_complex_acb_ctx with 53 bits of precision and retrieves its parent.

```python
>>> from flint.types._gr import gr_complex_acb_ctx
>>> acb = gr_complex_acb_ctx.new(53)
>>> x = acb("2")
>>> x.parent()
gr_complex_acb_ctx(53)
```

--------------------------------

### fmpz power example

Source: https://python-flint.readthedocs.io/en/latest/fmpz.html

Shows exponentiation of an fmpz integer, yielding an arbitrary-size integer result.

```python
>>> fmpz(3) ** 25
847288609443
```

--------------------------------

### Get a generator by index (fmpz_mpoly_ctx.gen)

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mpoly.html

Returns the i-th generator of the polynomial ring. The example retrieves the second generator (index 1) from a context with three variables.

```python
>>> ctx = fmpz_mpoly_ctx.get(('z', 3), 'degrevlex')
>>> ctx.gen(1)
z1
```

--------------------------------

### Get generator by index

Source: https://python-flint.readthedocs.io/en/latest/fmpq_mpoly.html

Shows how to retrieve a generator using gen with an index. The example uses fmpq_mpoly_ctx with degrevlex ordering and prints the second generator.

```python
>>> ctx = fmpq_mpoly_ctx.get(('z', 3), 'degrevlex')
>>> ctx.gen(1)
z1
```

--------------------------------

### Get generator of polynomial ring via gen()

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mod_poly.html

Returns the generator x of the polynomial ring. The example creates a context with modulus 163 and calls gen().

```python
>>> R = fmpz_mod_poly_ctx(163)
>>> R.gen()
x
```

--------------------------------

### Build with coverage and run coverage report (bin/coverage.sh)

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Builds Cython code with coverage enabled, runs the test suite, and generates coverage reports. The -Dcoverage=true option enables tracing, which slows down the build and runtime. This setting is persistent and must be explicitly disabled when no longer needed.

```bash
spin build -Dcoverage=true
spin run -- coverage run -m flint.test
coverage report -m --sort=cover
coverage html
```

--------------------------------

### monomial – Get exponent vector at index

Source: https://python-flint.readthedocs.io/en/latest/nmod_mpoly.html

Returns the exponent vector at a given index as a tuple. The example shows that for a polynomial with terms (0,1) and (1,1), the monomial at index 1 is (0,1).

```python
>>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex')
>>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3})
>>> p.monomial(1)
(0, 1)
```

--------------------------------

### Create and activate a Python virtual environment

Source: https://python-flint.readthedocs.io/en/latest/workflow.html

Creates a virtual environment named 'venv' and activates it. After activation, commands such as pip and python use this environment.

```bash
python3 -m venv venv
source venv/bin/activate
```

--------------------------------

### leading_coefficient – Get leading coefficient

Source: https://python-flint.readthedocs.io/en/latest/nmod_mpoly.html

Shows how to obtain the leading coefficient of a multivariate polynomial in the monomial ordering. The example uses a polynomial with several terms and returns the coefficient of the leading term.

```python
>>> ctx = nmod_mpoly_ctx.get(('x', 'y'), 11, 'lex')
>>> x, y = ctx.gens()
>>> p = 2*x*y + 3*x + 4*y**2 + 5
>>> p
2*x*y + 3*x + 4*y^2 + 5
>>> p.leading_coefficient()
2
```

--------------------------------

### Create fmpq_mpoly and get coefficient

Source: https://python-flint.readthedocs.io/en/latest/fmpq_mpoly.html

Shows how to create a multivariate polynomial over the rationals using fmpq_mpoly_ctx.get and retrieve a coefficient with the coefficient method.

```python
>>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex')
>>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3})
>>> p.coefficient(1)
2
```

--------------------------------

### Set LD_LIBRARY_PATH for runtime shared libraries

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

Set the LD_LIBRARY_PATH environment variable on Linux to add the directory containing the GMP, MPFR, and FLINT shared libraries to the dynamic linker search path at runtime. The example assumes FLINT is installed in ~/.local/lib.

```bash
export LD_LIBRARY_PATH=$(pwd)/.local/lib
```

--------------------------------

### compose() with different context

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mod_mpoly.html

Composes this polynomial with other fmpz_mod_mpolys. All arguments must share the same context, which may differ from this polynomial's context. The example composes x^2 with y0 + y1 to get y0^2 + 2*y0*y1 + y1^2.

```python
>>> ctx = fmpz_mod_mpoly_ctx.get(('x',), 11, 'lex')
>>> ctx1 = fmpz_mod_mpoly_ctx.get(('y', 2), 11, 'lex')
>>> f = ctx.from_dict({(2,): 1})
>>> g = ctx1.from_dict({(1, 0): 1, (0, 1): 1})
>>> f
x^2
>>> g
y0 + y1
>>> f.compose(g)
y0^2 + 2*y0*y1 + y1^2
```

--------------------------------

### fmpz.fac_ui example

Source: https://python-flint.readthedocs.io/en/latest/fmpz.html

Returns the factorial n! as an fmpz.

```python
>>> fmpz.fac_ui(10)
3628800
```

--------------------------------

### deflate() with given N

Source: https://python-flint.readthedocs.io/en/latest/fmpz_mod_mpoly.html

Computes the deflation of the polynomial for a provided list N, returning q such that q(X) = p(X^(1/N)). The example deflates x^3*y + x*y^4 + x*y with N=[2,3] to get x + y + 1.

```python
>>> ctx = fmpz_mod_mpoly_ctx.get(('x', 'y'), 11, 'lex')
>>> x, y = ctx.gens()
>>> f = x**3 * y + x * y**4 + x * y
>>> f.deflate([2, 3])
x + y + 1
```

--------------------------------

### Install python-flint with pip and pkg-config path

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

Pass the path to the pkg-config files to the meson-python build backend when building with pip. This allows the build system to find the FLINT library at build time.

```bash
pip install \
    --config-settings=setup-args="--pkg-config-path=$(pwd)/.local/lib/pkgconfig" \
    python-flint
```

--------------------------------

### Run python-flint test suite

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

Runs the full test suite and doctests for python-flint >= 0.5.0. Should complete quickly and report all tests passing.

```bash
python -m flint.test
```

--------------------------------

### Install python-flint with conda

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

Installs python-flint from conda-forge. Prebuilt binaries are available for common platforms.

```bash
conda install -c conda-forge python-flint
```
Tokens:
Raw